Initial Commit
This commit is contained in:
Jordan Sherer
@@ -0,0 +1,232 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2007 Joel de Guzman
|
||||
Copyright (c) 2004 Daniel Wallin
|
||||
Copyright (c) 2011 Thomas Heller
|
||||
|
||||
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 PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP
|
||||
#define PHOENIX_SCOPE_DETAIL_LOCAL_VARIABLE_HPP
|
||||
|
||||
#include <boost/mpl/int.hpp>
|
||||
#include <boost/mpl/bool.hpp>
|
||||
#include <boost/mpl/eval_if.hpp>
|
||||
#include <boost/mpl/identity.hpp>
|
||||
#include <boost/fusion/include/at.hpp>
|
||||
#include <boost/fusion/include/value_at.hpp>
|
||||
#include <boost/preprocessor/enum.hpp>
|
||||
#include <boost/preprocessor/repeat.hpp>
|
||||
#include <boost/type_traits/remove_reference.hpp>
|
||||
#include <boost/type_traits/is_reference.hpp>
|
||||
|
||||
#define BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM(z, n, data) \
|
||||
typename T##n = unused<n>
|
||||
|
||||
#define BOOST_PHOENIX_MAP_LOCAL_DISPATCH(z, n, data) \
|
||||
typedef char(&result##n)[n+2]; \
|
||||
static result##n get(T##n*);
|
||||
|
||||
namespace boost { namespace phoenix
|
||||
{
|
||||
template <typename Env, typename OuterEnv, typename Locals, typename Map>
|
||||
struct scoped_environment;
|
||||
|
||||
namespace detail
|
||||
{
|
||||
template <typename Key>
|
||||
struct local
|
||||
{
|
||||
typedef Key key_type;
|
||||
};
|
||||
|
||||
namespace result_of
|
||||
{
|
||||
template <typename Locals, typename Context>
|
||||
struct initialize_locals;
|
||||
|
||||
template <typename Context>
|
||||
struct initialize_locals<vector0<>, Context>
|
||||
{
|
||||
typedef vector0<> type;
|
||||
};
|
||||
|
||||
#define M1(Z, N, D) \
|
||||
typename boost::phoenix::result_of::eval< \
|
||||
BOOST_PP_CAT(A, N) \
|
||||
, Context \
|
||||
>::type \
|
||||
/**/
|
||||
|
||||
#define M0(Z, N, D) \
|
||||
template <BOOST_PHOENIX_typename_A(N), typename Context> \
|
||||
struct initialize_locals< \
|
||||
BOOST_PP_CAT(vector, N)< \
|
||||
BOOST_PHOENIX_A(N) \
|
||||
> \
|
||||
, Context \
|
||||
> \
|
||||
{ \
|
||||
typedef \
|
||||
BOOST_PP_CAT(vector, N)< \
|
||||
BOOST_PP_ENUM(N, M1, _) \
|
||||
> \
|
||||
type; \
|
||||
}; \
|
||||
/**/
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
|
||||
#undef M0
|
||||
}
|
||||
|
||||
template <typename Context>
|
||||
vector0<>
|
||||
initialize_locals(vector0<> const &, Context const &)
|
||||
{
|
||||
vector0<> vars;
|
||||
return vars;
|
||||
}
|
||||
#define M2(Z, N, D) \
|
||||
eval(locals. BOOST_PP_CAT(a, N), ctx) \
|
||||
/**/
|
||||
|
||||
#define M0(Z, N, D) \
|
||||
template <BOOST_PHOENIX_typename_A(N), typename Context> \
|
||||
BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, M1, _)> \
|
||||
initialize_locals( \
|
||||
BOOST_PP_CAT(vector, N)<BOOST_PHOENIX_A(N)> const & locals \
|
||||
, Context const & ctx \
|
||||
) \
|
||||
{ \
|
||||
BOOST_PP_CAT(vector, N)<BOOST_PP_ENUM(N, M1, _)> vars \
|
||||
= {BOOST_PP_ENUM(N, M2, _)}; \
|
||||
return vars; \
|
||||
} \
|
||||
/**/
|
||||
BOOST_PP_REPEAT_FROM_TO(1, BOOST_PHOENIX_LIMIT, M0, _)
|
||||
#undef M0
|
||||
#undef M1
|
||||
#undef M2
|
||||
|
||||
template <int N>
|
||||
struct unused;
|
||||
|
||||
template <
|
||||
BOOST_PP_ENUM(
|
||||
BOOST_PHOENIX_LOCAL_LIMIT
|
||||
, BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM
|
||||
, _
|
||||
)
|
||||
>
|
||||
struct map_local_index_to_tuple
|
||||
{
|
||||
typedef char(¬_found)[1];
|
||||
static not_found get(...);
|
||||
|
||||
BOOST_PP_REPEAT(BOOST_PHOENIX_LOCAL_LIMIT, BOOST_PHOENIX_MAP_LOCAL_DISPATCH, _)
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
T* generate_pointer();
|
||||
|
||||
template <typename Map, typename Tag>
|
||||
struct get_index
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(int,
|
||||
value = (
|
||||
static_cast<int>((sizeof(Map::get(generate_pointer<Tag>()))) / sizeof(char)) - 2
|
||||
));
|
||||
|
||||
// if value == -1, Tag is not found
|
||||
typedef mpl::int_<value> type;
|
||||
};
|
||||
|
||||
|
||||
template <typename Local, typename Env>
|
||||
struct apply_local;
|
||||
|
||||
template <typename Local, typename Env>
|
||||
struct outer_local
|
||||
{
|
||||
typedef typename
|
||||
apply_local<Local, typename Env::outer_env_type>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename Locals, int Index>
|
||||
struct get_local_or_void
|
||||
{
|
||||
typedef typename
|
||||
mpl::eval_if_c<
|
||||
Index < Locals::size_value
|
||||
, fusion::result_of::at_c<Locals, Index>
|
||||
, mpl::identity<fusion::void_>
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename Local, typename Env, int Index>
|
||||
struct get_local_from_index
|
||||
{
|
||||
typedef typename
|
||||
mpl::eval_if_c<
|
||||
Index == -1
|
||||
, outer_local<Local, Env>
|
||||
, get_local_or_void<typename Env::locals_type, Index>
|
||||
>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename Local, typename Env>
|
||||
struct get_local
|
||||
{
|
||||
static const int index_value = get_index<typename Env::map_type, Local>::value;
|
||||
|
||||
typedef typename
|
||||
get_local_from_index<Local, Env, index_value>::type
|
||||
type;
|
||||
};
|
||||
|
||||
template <typename Local, typename Env>
|
||||
struct apply_local
|
||||
{
|
||||
// $$$ TODO: static assert that Env is a scoped_environment $$$
|
||||
typedef typename get_local<Local, Env>::type type;
|
||||
};
|
||||
|
||||
template <typename Key>
|
||||
struct eval_local
|
||||
{
|
||||
template <typename RT, int Index, typename Env>
|
||||
static RT
|
||||
get(Env const& env, mpl::false_)
|
||||
{
|
||||
return RT(fusion::at_c<Index>(env.locals));
|
||||
}
|
||||
|
||||
template <typename RT, int Index, typename Env>
|
||||
static RT
|
||||
get(Env const& env, mpl::true_)
|
||||
{
|
||||
static const int index_value = get_index<typename Env::outer_env_type::map_type, detail::local<Key> >::value;
|
||||
|
||||
return get<RT, index_value>(
|
||||
env.outer_env
|
||||
, mpl::bool_<index_value == -1>());
|
||||
}
|
||||
|
||||
template <typename RT, int Index, typename Env>
|
||||
static RT
|
||||
get(Env const& env)
|
||||
{
|
||||
return get<RT, Index>(
|
||||
env
|
||||
, mpl::bool_<Index == -1>());
|
||||
}
|
||||
};
|
||||
}
|
||||
}}
|
||||
|
||||
#undef BOOST_PHOENIX_MAP_LOCAL_TEMPLATE_PARAM
|
||||
#undef BOOST_PHOENIX_MAP_LOCAL_DISPATCH
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,52 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
// *Preprocessed* version of the main "apply_fwd.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename F, typename T1 = na, typename T2 = na, typename T3 = na
|
||||
, typename T4 = na, typename T5 = na
|
||||
>
|
||||
struct apply;
|
||||
|
||||
template<
|
||||
typename F
|
||||
>
|
||||
struct apply0;
|
||||
|
||||
template<
|
||||
typename F, typename T1
|
||||
>
|
||||
struct apply1;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2
|
||||
>
|
||||
struct apply2;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3
|
||||
>
|
||||
struct apply3;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
>
|
||||
struct apply4;
|
||||
|
||||
template<
|
||||
typename F, typename T1, typename T2, typename T3, typename T4
|
||||
, typename T5
|
||||
>
|
||||
struct apply5;
|
||||
|
||||
}}
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
//---------------------------------------------------------------------------//
|
||||
// Copyright (c) 2013-2014 Kyle Lutz <kyle.r.lutz@gmail.com>
|
||||
//
|
||||
// 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://boostorg.github.com/compute for more information.
|
||||
//---------------------------------------------------------------------------//
|
||||
|
||||
#ifndef BOOST_COMPUTE_ALLOCATOR_HPP
|
||||
#define BOOST_COMPUTE_ALLOCATOR_HPP
|
||||
|
||||
/// \file
|
||||
///
|
||||
/// Meta-header to include all Boost.Compute allocator headers.
|
||||
|
||||
#include <boost/compute/allocator/buffer_allocator.hpp>
|
||||
#include <boost/compute/allocator/pinned_allocator.hpp>
|
||||
|
||||
#endif // BOOST_COMPUTE_ALLOCATOR_HPP
|
||||
@@ -0,0 +1,49 @@
|
||||
// Boost.Units - A C++ library for zero-overhead dimensional analysis and
|
||||
// unit/quantity manipulation and conversion
|
||||
//
|
||||
// Copyright (C) 2003-2008 Matthias Christian Schabel
|
||||
// Copyright (C) 2008 Steven Watanabe
|
||||
//
|
||||
// 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_UNITS_MASS_BASE_DIMENSION_HPP
|
||||
#define BOOST_UNITS_MASS_BASE_DIMENSION_HPP
|
||||
|
||||
#include <boost/units/config.hpp>
|
||||
#include <boost/units/base_dimension.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
/// base dimension of mass
|
||||
struct mass_base_dimension :
|
||||
boost::units::base_dimension<mass_base_dimension,-8>
|
||||
{ };
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#if BOOST_UNITS_HAS_BOOST_TYPEOF
|
||||
|
||||
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
|
||||
|
||||
BOOST_TYPEOF_REGISTER_TYPE(boost::units::mass_base_dimension)
|
||||
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
namespace units {
|
||||
|
||||
/// dimension of mass (M)
|
||||
typedef mass_base_dimension::dimension_type mass_dimension;
|
||||
|
||||
} // namespace units
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // BOOST_UNITS_MASS_BASE_DIMENSION_HPP
|
||||
@@ -0,0 +1,761 @@
|
||||
// (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 : simple implementation for Unit Test Framework parameter
|
||||
// handling routines. May be rewritten in future to use some kind of
|
||||
// command-line arguments parsing facility and environment variable handling
|
||||
// facility
|
||||
// ***************************************************************************
|
||||
|
||||
#ifndef BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
|
||||
#define BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
|
||||
|
||||
// Boost.Test
|
||||
#include <boost/test/unit_test_parameters.hpp>
|
||||
|
||||
#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
|
||||
#include <boost/test/utils/basic_cstring/compare.hpp>
|
||||
#include <boost/test/utils/basic_cstring/io.hpp>
|
||||
#include <boost/test/utils/iterator/token_iterator.hpp>
|
||||
|
||||
#include <boost/test/debug.hpp>
|
||||
#include <boost/test/framework.hpp>
|
||||
|
||||
#include <boost/test/detail/log_level.hpp>
|
||||
#include <boost/test/detail/throw_exception.hpp>
|
||||
|
||||
// Boost.Runtime.Param
|
||||
#include <boost/test/utils/runtime/parameter.hpp>
|
||||
#include <boost/test/utils/runtime/argument.hpp>
|
||||
#include <boost/test/utils/runtime/finalize.hpp>
|
||||
#include <boost/test/utils/runtime/cla/parser.hpp>
|
||||
#include <boost/test/utils/runtime/env/fetch.hpp>
|
||||
|
||||
// Boost
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/test/detail/suppress_warnings.hpp>
|
||||
#include <boost/test/detail/enable_warnings.hpp>
|
||||
#include <boost/optional.hpp>
|
||||
#include <boost/cstdlib.hpp>
|
||||
|
||||
// STL
|
||||
#include <cstdlib>
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/test/detail/suppress_warnings.hpp>
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
# ifdef BOOST_NO_STDC_NAMESPACE
|
||||
namespace std { using ::getenv; using ::strncmp; using ::strcmp; }
|
||||
# endif
|
||||
|
||||
namespace boost {
|
||||
namespace unit_test {
|
||||
|
||||
namespace rt = boost::runtime;
|
||||
|
||||
// ************************************************************************** //
|
||||
// ************** runtime_config ************** //
|
||||
// ************************************************************************** //
|
||||
|
||||
namespace runtime_config {
|
||||
|
||||
// UTF parameters
|
||||
std::string AUTO_START_DBG = "auto_start_dbg";
|
||||
std::string BREAK_EXEC_PATH = "break_exec_path";
|
||||
std::string BUILD_INFO = "build_info";
|
||||
std::string CATCH_SYS_ERRORS = "catch_system_errors";
|
||||
std::string COLOR_OUTPUT = "color_output";
|
||||
std::string DETECT_FP_EXCEPT = "detect_fp_exceptions";
|
||||
std::string DETECT_MEM_LEAKS = "detect_memory_leaks";
|
||||
std::string LIST_CONTENT = "list_content";
|
||||
std::string LIST_LABELS = "list_labels";
|
||||
std::string LOG_FORMAT = "log_format";
|
||||
std::string LOG_LEVEL = "log_level";
|
||||
std::string LOG_SINK = "log_sink";
|
||||
std::string COMBINED_LOGGER = "logger";
|
||||
std::string OUTPUT_FORMAT = "output_format";
|
||||
std::string RANDOM_SEED = "random";
|
||||
std::string REPORT_FORMAT = "report_format";
|
||||
std::string REPORT_LEVEL = "report_level";
|
||||
std::string REPORT_MEM_LEAKS = "report_memory_leaks_to";
|
||||
std::string REPORT_SINK = "report_sink";
|
||||
std::string RESULT_CODE = "result_code";
|
||||
std::string RUN_FILTERS = "run_test";
|
||||
std::string SAVE_TEST_PATTERN = "save_pattern";
|
||||
std::string SHOW_PROGRESS = "show_progress";
|
||||
std::string USE_ALT_STACK = "use_alt_stack";
|
||||
std::string WAIT_FOR_DEBUGGER = "wait_for_debugger";
|
||||
|
||||
std::string HELP = "help";
|
||||
std::string USAGE = "usage";
|
||||
std::string VERSION = "version";
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
namespace {
|
||||
|
||||
void
|
||||
register_parameters( rt::parameters_store& store )
|
||||
{
|
||||
rt::option auto_start_dbg( AUTO_START_DBG, (
|
||||
rt::description = "Automatically attaches debugger in case of system level failure (signal).",
|
||||
rt::env_var = "BOOST_TEST_AUTO_START_DBG",
|
||||
|
||||
rt::help = "Option " + AUTO_START_DBG + " specifies whether Boost.Test should attempt "
|
||||
"to attach a debugger when fatal system error occurs. At the moment this feature "
|
||||
"is only available on a few selected platforms: Win32 and *nix. There is a "
|
||||
"default debugger configured for these platforms. You can manually configure "
|
||||
"different debugger. For more details on how to configure the debugger see the "
|
||||
"Boost.Test debug API, specifically the function boost::debug::set_debugger."
|
||||
));
|
||||
|
||||
auto_start_dbg.add_cla_id( "--", AUTO_START_DBG, "=" );
|
||||
auto_start_dbg.add_cla_id( "-", "d", " " );
|
||||
store.add( auto_start_dbg );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string> break_exec_path( BREAK_EXEC_PATH, (
|
||||
rt::description = "For the exception safety testing allows to break at specific execution path.",
|
||||
rt::env_var = "BOOST_TEST_BREAK_EXEC_PATH"
|
||||
#ifndef BOOST_NO_CXX11_LAMBDAS
|
||||
,
|
||||
rt::callback = [](rt::cstring) {
|
||||
BOOST_TEST_SETUP_ASSERT( false, "parameter break_exec_path is disabled in this release" );
|
||||
}
|
||||
#endif
|
||||
));
|
||||
|
||||
break_exec_path.add_cla_id( "--", BREAK_EXEC_PATH, "=" );
|
||||
store.add( break_exec_path );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option build_info( BUILD_INFO, (
|
||||
rt::description = "Displays library build information.",
|
||||
rt::env_var = "BOOST_TEST_BUILD_INFO",
|
||||
rt::help = "Option " + BUILD_INFO + " displays library build information, including: platform, "
|
||||
"compiler, STL version and Boost version."
|
||||
));
|
||||
|
||||
build_info.add_cla_id( "--", BUILD_INFO, "=" );
|
||||
build_info.add_cla_id( "-", "i", " " );
|
||||
store.add( build_info );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option catch_sys_errors( CATCH_SYS_ERRORS, (
|
||||
rt::description = "Allows to switch between catching and ignoring system errors (signals).",
|
||||
rt::env_var = "BOOST_TEST_CATCH_SYSTEM_ERRORS",
|
||||
rt::default_value =
|
||||
#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
|
||||
false,
|
||||
#else
|
||||
true,
|
||||
#endif
|
||||
rt::help = "If option " + CATCH_SYS_ERRORS + " has value no the frameworks does not attempt to catch "
|
||||
"asynchronous system failure events (signals on *NIX platforms or structured exceptions on Windows). "
|
||||
" Default value is "
|
||||
#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
|
||||
"no."
|
||||
#else
|
||||
"true."
|
||||
#endif
|
||||
));
|
||||
|
||||
catch_sys_errors.add_cla_id( "--", CATCH_SYS_ERRORS, "=", true );
|
||||
catch_sys_errors.add_cla_id( "-", "s", " " );
|
||||
store.add( catch_sys_errors );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option color_output( COLOR_OUTPUT, (
|
||||
rt::description = "Enables color output of the framework log and report messages.",
|
||||
rt::env_var = "BOOST_TEST_COLOR_OUTPUT",
|
||||
rt::help = "The framework is able to produce color output on systems which supports it. "
|
||||
"To enable this behavior set this option to yes. By default the framework "
|
||||
"does not produces color output."
|
||||
));
|
||||
|
||||
color_output.add_cla_id( "--", COLOR_OUTPUT, "=", true );
|
||||
color_output.add_cla_id( "-", "x", " " );
|
||||
store.add( color_output );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option detect_fp_except( DETECT_FP_EXCEPT, (
|
||||
rt::description = "Enables/disables floating point exceptions traps.",
|
||||
rt::env_var = "BOOST_TEST_DETECT_FP_EXCEPTIONS",
|
||||
rt::help = "Option " + DETECT_FP_EXCEPT + " enables/disables hardware traps for the floating "
|
||||
"point exceptions (if supported on your platfrom)."
|
||||
));
|
||||
|
||||
detect_fp_except.add_cla_id( "--", DETECT_FP_EXCEPT, "=", true );
|
||||
store.add( detect_fp_except );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<unsigned long> detect_mem_leaks( DETECT_MEM_LEAKS, (
|
||||
rt::description = "Turns on/off memory leaks detection (optionally breaking on specified alloc order number).",
|
||||
rt::env_var = "BOOST_TEST_DETECT_MEMORY_LEAK",
|
||||
rt::default_value = 1L,
|
||||
rt::optional_value = 1L,
|
||||
rt::value_hint = "<alloc order number>",
|
||||
rt::help = "Parameter " + DETECT_MEM_LEAKS + " enables/disables memory leaks detection. "
|
||||
"This parameter has optional long integer value. The default value is 1, which "
|
||||
"enables the memory leak detection. The value 0 disables memory leak detection. "
|
||||
"Any value N greater than 1 is treated as leak allocation number and tells the "
|
||||
"framework to setup runtime breakpoint at Nth heap allocation. If value is "
|
||||
"omitted the default value is assumed."
|
||||
));
|
||||
|
||||
detect_mem_leaks.add_cla_id( "--", DETECT_MEM_LEAKS, "=" );
|
||||
store.add( detect_mem_leaks );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::output_format> list_content( LIST_CONTENT, (
|
||||
rt::description = "Lists the content of test tree - names of all test suites and test cases.",
|
||||
rt::env_var = "BOOST_TEST_LIST_CONTENT",
|
||||
rt::default_value = OF_INVALID,
|
||||
rt::optional_value = OF_CLF,
|
||||
rt::enum_values<unit_test::output_format>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "HRF", OF_CLF },
|
||||
{ "DOT", OF_DOT }
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::output_format>()
|
||||
( "HRF", OF_CLF )
|
||||
( "DOT", OF_DOT )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + LIST_CONTENT + " instructs the framework to list the content "
|
||||
"of the test module instead of executing the test cases. Parameter accepts "
|
||||
"optional string value indicating the format of the output. Currently the "
|
||||
"framework supports two formats: human readable format (HRF) and dot graph "
|
||||
"format (DOT). If value is omitted HRF value is assumed."
|
||||
));
|
||||
list_content.add_cla_id( "--", LIST_CONTENT, "=" );
|
||||
store.add( list_content );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option list_labels( LIST_LABELS, (
|
||||
rt::description = "Lists all available labels.",
|
||||
rt::env_var = "BOOST_TEST_LIST_LABELS",
|
||||
rt::help = "Option " + LIST_LABELS + " instructs the framework to list all the the labels "
|
||||
"defined in the test module instead of executing the test cases."
|
||||
));
|
||||
|
||||
list_labels.add_cla_id( "--", LIST_LABELS, "=" );
|
||||
store.add( list_labels );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::output_format> log_format( LOG_FORMAT, (
|
||||
rt::description = "Specifies log format.",
|
||||
rt::env_var = "BOOST_TEST_LOG_FORMAT",
|
||||
rt::default_value = OF_CLF,
|
||||
rt::enum_values<unit_test::output_format>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "HRF", OF_CLF },
|
||||
{ "CLF", OF_CLF },
|
||||
{ "XML", OF_XML },
|
||||
{ "JUNIT", OF_JUNIT },
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::output_format>()
|
||||
( "HRF", OF_CLF )
|
||||
( "CLF", OF_CLF )
|
||||
( "XML", OF_XML )
|
||||
( "JUNIT", OF_JUNIT )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + LOG_FORMAT + " allows to set the frameowrk's log format to one "
|
||||
"of the formats supplied by the framework. The only acceptable values for this "
|
||||
"parameter are the names of the output formats supplied by the framework. By "
|
||||
"default the framework uses human readable format (HRF) for testing log. This "
|
||||
"format is similar to compiler error format. Alternatively you can specify XML "
|
||||
"or JUNIT as log format, which are easier to process by testing automation tools."
|
||||
));
|
||||
|
||||
log_format.add_cla_id( "--", LOG_FORMAT, "=" );
|
||||
log_format.add_cla_id( "-", "f", " " );
|
||||
store.add( log_format );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::log_level> log_level( LOG_LEVEL, (
|
||||
rt::description = "Specifies log level.",
|
||||
rt::env_var = "BOOST_TEST_LOG_LEVEL",
|
||||
rt::default_value = log_all_errors,
|
||||
rt::enum_values<unit_test::log_level>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "all" , log_successful_tests },
|
||||
{ "success" , log_successful_tests },
|
||||
{ "test_suite" , log_test_units },
|
||||
{ "unit_scope" , log_test_units },
|
||||
{ "message" , log_messages },
|
||||
{ "warning" , log_warnings },
|
||||
{ "error" , log_all_errors },
|
||||
{ "cpp_exception" , log_cpp_exception_errors },
|
||||
{ "system_error" , log_system_errors },
|
||||
{ "fatal_error" , log_fatal_errors },
|
||||
{ "nothing" , log_nothing }
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::log_level>()
|
||||
( "all" , log_successful_tests )
|
||||
( "success" , log_successful_tests )
|
||||
( "test_suite" , log_test_units )
|
||||
( "unit_scope" , log_test_units )
|
||||
( "message" , log_messages )
|
||||
( "warning" , log_warnings )
|
||||
( "error" , log_all_errors )
|
||||
( "cpp_exception" , log_cpp_exception_errors )
|
||||
( "system_error" , log_system_errors )
|
||||
( "fatal_error" , log_fatal_errors )
|
||||
( "nothing" , log_nothing )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + LOG_LEVEL + " allows to set the framework's log level. "
|
||||
"Log level defines the verbosity of testing log produced by a testing "
|
||||
"module. The verbosity ranges from a complete log, when all assertions "
|
||||
"(both successful and failing) are reported, all notifications about "
|
||||
"test units start and finish are included, to an empty log when nothing "
|
||||
"is reported to a testing log stream."
|
||||
));
|
||||
|
||||
log_level.add_cla_id( "--", LOG_LEVEL, "=" );
|
||||
log_level.add_cla_id( "-", "l", " " );
|
||||
store.add( log_level );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string> log_sink( LOG_SINK, (
|
||||
rt::description = "Specifies log sink: stdout(default), stderr or file name.",
|
||||
rt::env_var = "BOOST_TEST_LOG_SINK",
|
||||
rt::value_hint = "<stderr|stdout|file name>",
|
||||
rt::help = "Parameter " + LOG_SINK + " allows to set the log sink - location "
|
||||
"where we report the log to, thus it allows to easily redirect the "
|
||||
"test logs to file or standard streams. By default testing log is "
|
||||
"directed to standard output."
|
||||
));
|
||||
|
||||
log_sink.add_cla_id( "--", LOG_SINK, "=" );
|
||||
log_sink.add_cla_id( "-", "k", " " );
|
||||
store.add( log_sink );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::output_format> output_format( OUTPUT_FORMAT, (
|
||||
rt::description = "Specifies output format (both log and report).",
|
||||
rt::env_var = "BOOST_TEST_OUTPUT_FORMAT",
|
||||
rt::enum_values<unit_test::output_format>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "HRF", OF_CLF },
|
||||
{ "CLF", OF_CLF },
|
||||
{ "XML", OF_XML }
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::output_format>()
|
||||
( "HRF", OF_CLF )
|
||||
( "CLF", OF_CLF )
|
||||
( "XML", OF_XML )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + OUTPUT_FORMAT + " combines an effect of " + REPORT_FORMAT +
|
||||
" and " + LOG_FORMAT + " parameters. This parameter has higher priority "
|
||||
"than either one of them. In other words if this parameter is specified "
|
||||
"it overrides the value of other two parameters. This parameter does not "
|
||||
"have a default value. The only acceptable values are string names of "
|
||||
"output formats: HRF - human readable format and XML - XML formats for "
|
||||
"automation tools processing."
|
||||
));
|
||||
|
||||
output_format.add_cla_id( "--", OUTPUT_FORMAT, "=" );
|
||||
output_format.add_cla_id( "-", "o", " " );
|
||||
store.add( output_format );
|
||||
|
||||
/////////////////////////////////////////////// combined logger option
|
||||
|
||||
rt::parameter<std::string,rt::REPEATABLE_PARAM> combined_logger( COMBINED_LOGGER, (
|
||||
rt::description = "Specifies log level and sink for one or several log format",
|
||||
rt::env_var = "BOOST_TEST_LOGGER",
|
||||
rt::value_hint = "log_format:log_level:log_sink",
|
||||
rt::help = "Parameter " + COMBINED_LOGGER + " allows to specify the logger type, level and sink\n"
|
||||
"in one command."
|
||||
));
|
||||
|
||||
combined_logger.add_cla_id( "--", COMBINED_LOGGER, "=" );
|
||||
store.add( combined_logger );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<unsigned> random_seed( RANDOM_SEED, (
|
||||
rt::description = "Allows to switch between sequential and random order of test units execution."
|
||||
" Optionally allows to specify concrete seed for random number generator.",
|
||||
rt::env_var = "BOOST_TEST_RANDOM",
|
||||
rt::default_value = 0U,
|
||||
rt::optional_value = 1U,
|
||||
rt::value_hint = "<seed>",
|
||||
rt::help = "Parameter " + RANDOM_SEED + " instructs the framework to execute the "
|
||||
"test cases in random order. This parameter accepts optional unsigned "
|
||||
"integer argument. By default test cases are executed in some specific "
|
||||
"order defined by order of test units in test files and dependency between "
|
||||
"test units. If parameter is specified without the argument value testing "
|
||||
"order is randomized based on current time. Alternatively you can specify "
|
||||
"any positive value greater than 1 and it will be used as random seed for "
|
||||
"the run."
|
||||
));
|
||||
|
||||
random_seed.add_cla_id( "--", RANDOM_SEED, "=" );
|
||||
store.add( random_seed );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::output_format> report_format( REPORT_FORMAT, (
|
||||
rt::description = "Specifies report format.",
|
||||
rt::env_var = "BOOST_TEST_REPORT_FORMAT",
|
||||
rt::default_value = OF_CLF,
|
||||
rt::enum_values<unit_test::output_format>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "HRF", OF_CLF },
|
||||
{ "CLF", OF_CLF },
|
||||
{ "XML", OF_XML }
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::output_format>()
|
||||
( "HRF", OF_CLF )
|
||||
( "CLF", OF_CLF )
|
||||
( "XML", OF_XML )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + REPORT_FORMAT + " allows to set the framework's report format "
|
||||
"to one of the formats supplied by the framework. The only acceptable values "
|
||||
"for this parameter are the names of the output formats. By default the framework "
|
||||
"uses human readable format (HRF) for results reporting. Alternatively you can "
|
||||
"specify XML as report format. This format is easier to process by testing "
|
||||
"automation tools."
|
||||
));
|
||||
|
||||
report_format.add_cla_id( "--", REPORT_FORMAT, "=" );
|
||||
report_format.add_cla_id( "-", "m", " " );
|
||||
store.add( report_format );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::enum_parameter<unit_test::report_level> report_level( REPORT_LEVEL, (
|
||||
rt::description = "Specifies report level.",
|
||||
rt::env_var = "BOOST_TEST_REPORT_LEVEL",
|
||||
rt::default_value = CONFIRMATION_REPORT,
|
||||
rt::enum_values<unit_test::report_level>::value =
|
||||
#if defined(BOOST_TEST_CLA_NEW_API)
|
||||
{
|
||||
{ "confirm", CONFIRMATION_REPORT },
|
||||
{ "short", SHORT_REPORT },
|
||||
{ "detailed", DETAILED_REPORT },
|
||||
{ "no", NO_REPORT }
|
||||
},
|
||||
#else
|
||||
rt::enum_values_list<unit_test::report_level>()
|
||||
( "confirm", CONFIRMATION_REPORT )
|
||||
( "short", SHORT_REPORT )
|
||||
( "detailed", DETAILED_REPORT )
|
||||
( "no", NO_REPORT )
|
||||
,
|
||||
#endif
|
||||
rt::help = "Parameter " + REPORT_LEVEL + " allows to set the verbosity level of the "
|
||||
"testing result report generated by the framework. Use value 'no' to "
|
||||
"eliminate the results report completely."
|
||||
));
|
||||
|
||||
report_level.add_cla_id( "--", REPORT_LEVEL, "=" );
|
||||
report_level.add_cla_id( "-", "r", " " );
|
||||
store.add( report_level );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string> report_mem_leaks( REPORT_MEM_LEAKS, (
|
||||
rt::description = "File where to report memory leaks to.",
|
||||
rt::env_var = "BOOST_TEST_REPORT_MEMORY_LEAKS_TO",
|
||||
rt::default_value = std::string(),
|
||||
rt::value_hint = "<file name>",
|
||||
rt::help = "Parameter " + REPORT_MEM_LEAKS + " allows to specify a file where to report "
|
||||
"memory leaks to. The parameter does not have default value. If it is not specified, "
|
||||
"memory leaks (if any) are reported to the standard error stream."
|
||||
));
|
||||
|
||||
report_mem_leaks.add_cla_id( "--", REPORT_MEM_LEAKS, "=" );
|
||||
store.add( report_mem_leaks );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string> report_sink( REPORT_SINK, (
|
||||
rt::description = "Specifies report sink: stderr(default), stdout or file name.",
|
||||
rt::env_var = "BOOST_TEST_REPORT_SINK",
|
||||
rt::value_hint = "<stderr|stdout|file name>",
|
||||
rt::help = "Parameter " + REPORT_SINK + " allows to set the result report sink - "
|
||||
"the location where the framework writes the result report to, thus it "
|
||||
"allows to easily redirect the result report to a file or a standard "
|
||||
"stream. By default the testing result report is directed to the "
|
||||
"standard error stream."
|
||||
));
|
||||
|
||||
report_sink.add_cla_id( "--", REPORT_SINK, "=" );
|
||||
report_sink.add_cla_id( "-", "e", " " );
|
||||
store.add( report_sink );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option result_code( RESULT_CODE, (
|
||||
rt::description = "Disables test modules's result code generation.",
|
||||
rt::env_var = "BOOST_TEST_RESULT_CODE",
|
||||
rt::default_value = true,
|
||||
rt::help = "The 'no' argument value for the parameter " + RESULT_CODE + " instructs the "
|
||||
"framework to always return zero result code. This can be used for test programs "
|
||||
"executed within IDE. By default this parameter has value 'yes'."
|
||||
));
|
||||
|
||||
result_code.add_cla_id( "--", RESULT_CODE, "=", true );
|
||||
result_code.add_cla_id( "-", "c", " " );
|
||||
store.add( result_code );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string,rt::REPEATABLE_PARAM> tests_to_run( RUN_FILTERS, (
|
||||
rt::description = "Filters, which test units to include or exclude from test module execution.",
|
||||
rt::env_var = "BOOST_TEST_RUN_FILTERS",
|
||||
rt::value_hint = "<test unit filter>",
|
||||
rt::help = "Parameter " + RUN_FILTERS + " allows to filter which test units to execute during "
|
||||
"testing. The framework supports both 'selection filters', which allow to select "
|
||||
"which test units to enable from the set of available test units, and 'disabler "
|
||||
"filters', which allow to disable some test units. The __UTF__ also supports "
|
||||
"enabling/disabling test units at compile time. These settings identify the default "
|
||||
"set of test units to run. Parameter " + RUN_FILTERS + " is used to change this default. "
|
||||
"This parameter is repeatable, so you can specify more than one filter if necessary."
|
||||
));
|
||||
|
||||
tests_to_run.add_cla_id( "--", RUN_FILTERS, "=" );
|
||||
tests_to_run.add_cla_id( "-", "t", " " );
|
||||
store.add( tests_to_run );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option save_test_pattern( SAVE_TEST_PATTERN, (
|
||||
rt::description = "Allows to switch between saving or matching test pattern file.",
|
||||
rt::env_var = "BOOST_TEST_SAVE_PATTERN",
|
||||
rt::help = "Parameter " + SAVE_TEST_PATTERN + " facilitates switching mode of operation for "
|
||||
"testing output streams.\n\nThis parameter serves no particular purpose within the "
|
||||
"framework itself. It can be used by test modules relying on output_test_stream to "
|
||||
"implement testing logic. Default mode is 'match' (false)."
|
||||
));
|
||||
|
||||
save_test_pattern.add_cla_id( "--", SAVE_TEST_PATTERN, "=" );
|
||||
store.add( save_test_pattern );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option show_progress( SHOW_PROGRESS, (
|
||||
rt::description = "Turns on progress display.",
|
||||
rt::env_var = "BOOST_TEST_SHOW_PROGRESS",
|
||||
rt::help = "Parameter " + SHOW_PROGRESS + " instructs the framework to display test progress "
|
||||
"information. By default the test progress is not shown."
|
||||
));
|
||||
|
||||
show_progress.add_cla_id( "--", SHOW_PROGRESS, "=" );
|
||||
show_progress.add_cla_id( "-", "p", " " );
|
||||
store.add( show_progress );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option use_alt_stack( USE_ALT_STACK, (
|
||||
rt::description = "Turns on/off usage of an alternative stack for signal handling.",
|
||||
rt::env_var = "BOOST_TEST_USE_ALT_STACK",
|
||||
rt::default_value = true,
|
||||
rt::help = "Parameter " + USE_ALT_STACK + " instructs the framework to use alternative "
|
||||
"stack for signals processing, on platforms where they are supported. The feature "
|
||||
"is enabled by default, but can be disabled using this parameter."
|
||||
));
|
||||
|
||||
use_alt_stack.add_cla_id( "--", USE_ALT_STACK, "=", true );
|
||||
store.add( use_alt_stack );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option wait_for_debugger( WAIT_FOR_DEBUGGER, (
|
||||
rt::description = "Forces test module to wait for button to be pressed before starting test run.",
|
||||
rt::env_var = "BOOST_TEST_WAIT_FOR_DEBUGGER",
|
||||
rt::help = "Parameter " + WAIT_FOR_DEBUGGER + " instructs the framework to pause before starting "
|
||||
"test units execution, so that you can attach a debugger to running test module. By "
|
||||
"default this parameters turned off."
|
||||
));
|
||||
|
||||
wait_for_debugger.add_cla_id( "--", WAIT_FOR_DEBUGGER, "=" );
|
||||
wait_for_debugger.add_cla_id( "-", "w", " " );
|
||||
store.add( wait_for_debugger );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::parameter<std::string> help( HELP, (
|
||||
rt::description = "Help for framework parameters.",
|
||||
rt::optional_value = std::string(),
|
||||
rt::value_hint = "<parameter name>",
|
||||
rt::help = "Parameter " + HELP + " displays help on the framework's parameters. "
|
||||
"The parameter accepts an optional argument value. If present, an argument value is "
|
||||
"interpreted as a parameter name (name guessing works as well, so for example "
|
||||
"--help=rand displays help on the parameter random). If the parameter name is unknown "
|
||||
"or ambiguous error is reported. If argument value is absent, a summary of all "
|
||||
"framework's parameter is displayed."
|
||||
));
|
||||
help.add_cla_id( "--", HELP, "=" );
|
||||
store.add( help );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option usage( USAGE, (
|
||||
rt::description = "Short message explaining usage of Boost.Test parameters."
|
||||
));
|
||||
usage.add_cla_id( "-", "?", " " );
|
||||
store.add( usage );
|
||||
|
||||
///////////////////////////////////////////////
|
||||
|
||||
rt::option version( VERSION, (
|
||||
rt::description = "Prints Boost.Test version and exits."
|
||||
));
|
||||
version.add_cla_id( "--", VERSION, " " );
|
||||
store.add( version );
|
||||
}
|
||||
|
||||
static rt::arguments_store s_arguments_store;
|
||||
static rt::parameters_store s_parameters_store;
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
} // local namespace
|
||||
|
||||
void
|
||||
init( int& argc, char** argv )
|
||||
{
|
||||
shared_ptr<rt::cla::parser> parser;
|
||||
|
||||
BOOST_TEST_I_TRY {
|
||||
// Initialize parameters list
|
||||
if( s_parameters_store.is_empty() )
|
||||
register_parameters( s_parameters_store );
|
||||
|
||||
// Clear up arguments store just in case (of multiple init invocations)
|
||||
s_arguments_store.clear();
|
||||
|
||||
// Parse CLA they take precedence over environment
|
||||
parser.reset( new rt::cla::parser( s_parameters_store, (rt::end_of_params = "--", rt::negation_prefix = "no_") ) );
|
||||
argc = parser->parse( argc, argv, s_arguments_store );
|
||||
|
||||
// Try to fetch missing arguments from environment
|
||||
rt::env::fetch_absent( s_parameters_store, s_arguments_store );
|
||||
|
||||
// Set arguments to default values if defined and perform all the validations
|
||||
rt::finalize_arguments( s_parameters_store, s_arguments_store );
|
||||
|
||||
// Report help if requested
|
||||
if( runtime_config::get<bool>( VERSION ) ) {
|
||||
parser->version( std::cerr );
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) );
|
||||
}
|
||||
else if( runtime_config::get<bool>( USAGE ) ) {
|
||||
parser->usage( std::cerr );
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) );
|
||||
}
|
||||
else if( s_arguments_store.has( HELP ) ) {
|
||||
parser->help( std::cerr, s_parameters_store, runtime_config::get<std::string>( HELP ) );
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) );
|
||||
}
|
||||
|
||||
// A bit of business logic: output_format takes precedence over log/report formats
|
||||
if( s_arguments_store.has( OUTPUT_FORMAT ) ) {
|
||||
unit_test::output_format of = s_arguments_store.get<unit_test::output_format>( OUTPUT_FORMAT );
|
||||
s_arguments_store.set( REPORT_FORMAT, of );
|
||||
s_arguments_store.set( LOG_FORMAT, of );
|
||||
}
|
||||
|
||||
}
|
||||
BOOST_TEST_I_CATCH( rt::init_error, ex ) {
|
||||
BOOST_TEST_SETUP_ASSERT( false, ex.msg );
|
||||
}
|
||||
BOOST_TEST_I_CATCH( rt::ambiguous_param, ex ) {
|
||||
std::cerr << ex.msg << "\n Did you mean one of these?\n";
|
||||
|
||||
BOOST_TEST_FOREACH( rt::cstring, name, ex.m_amb_candidates )
|
||||
std::cerr << " " << name << "\n";
|
||||
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
|
||||
}
|
||||
BOOST_TEST_I_CATCH( rt::unrecognized_param, ex ) {
|
||||
std::cerr << ex.msg << "\n";
|
||||
|
||||
if( !ex.m_typo_candidates.empty() ) {
|
||||
std::cerr << " Did you mean one of these?\n";
|
||||
|
||||
BOOST_TEST_FOREACH( rt::cstring, name, ex.m_typo_candidates )
|
||||
std::cerr << " " << name << "\n";
|
||||
}
|
||||
else if( parser ) {
|
||||
std::cerr << "\n";
|
||||
parser->usage( std::cerr );
|
||||
}
|
||||
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
|
||||
}
|
||||
BOOST_TEST_I_CATCH( rt::input_error, ex ) {
|
||||
std::cerr << ex.msg << "\n\n";
|
||||
|
||||
if( parser )
|
||||
parser->usage( std::cerr, ex.param_name );
|
||||
|
||||
BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
|
||||
}
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
rt::arguments_store const&
|
||||
argument_store()
|
||||
{
|
||||
return s_arguments_store;
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
bool
|
||||
save_pattern()
|
||||
{
|
||||
return runtime_config::get<bool>( SAVE_TEST_PATTERN );
|
||||
}
|
||||
|
||||
//____________________________________________________________________________//
|
||||
|
||||
} // namespace runtime_config
|
||||
} // namespace unit_test
|
||||
} // namespace boost
|
||||
|
||||
#include <boost/test/detail/enable_warnings.hpp>
|
||||
|
||||
#endif // BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
|
||||
@@ -0,0 +1,145 @@
|
||||
subroutine extract2(s3,nadd,ntrials,param,msg)
|
||||
|
||||
real s3(64,63)
|
||||
real tmp(4032)
|
||||
integer np1(0:7,0:7),np2(0:7,0:7),np0(0:7,0:7)
|
||||
integer ns(0:7,0:7)
|
||||
integer perr(0:7,0:7),pmr2(0:7,0:7)
|
||||
character msg*22
|
||||
integer dat4(12)
|
||||
integer mrsym(0:62),mr2sym(0:62),mrprob(0:62),mr2prob(0:62)
|
||||
integer correct(0:62)
|
||||
integer param(0:7)
|
||||
integer indx(0:62)
|
||||
logical first
|
||||
real*8 tt
|
||||
common/extcom/ntdecode
|
||||
data ndone/0/,ngood/0/,nbad/0/,first/.true./
|
||||
save
|
||||
|
||||
if(first) then
|
||||
np1=0
|
||||
np2=0
|
||||
np0=0
|
||||
ns=0
|
||||
first=.false.
|
||||
endif
|
||||
|
||||
nfail=0
|
||||
1 call demod64a(s3,nadd,mrsym,mrprob,mr2sym,mr2prob,ntest,nlow)
|
||||
|
||||
! if(ntest.lt.50 .or. nlow.gt.20) then
|
||||
! ncount=-999 !Flag bad data
|
||||
! go to 900
|
||||
! endif
|
||||
|
||||
call chkhist(mrsym,nhist,ipk)
|
||||
if(nhist.ge.20) then
|
||||
nfail=nfail+1
|
||||
call pctile(s3,tmp,4032,50,base) ! ### or, use ave from demod64a ?
|
||||
do j=1,63
|
||||
s3(ipk,j)=base
|
||||
enddo
|
||||
go to 1
|
||||
endif
|
||||
|
||||
call graycode(mrsym,63,-1)
|
||||
call interleave63(mrsym,-1)
|
||||
call interleave63(mrprob,-1)
|
||||
|
||||
call graycode(mr2sym,63,-1)
|
||||
call interleave63(mr2sym,-1)
|
||||
call interleave63(mr2prob,-1)
|
||||
|
||||
nverbose=0
|
||||
call ftrsd2(mrsym,mrprob,mr2sym,mr2prob,ntrials,nverbose,correct, &
|
||||
param,indx,tt,ntry)
|
||||
ncandidates=param(0)
|
||||
nhard=param(1)
|
||||
nsoft=param(2)
|
||||
nera=param(3)
|
||||
ngmd=param(4)
|
||||
ndone=ndone+1
|
||||
|
||||
do i=1,12
|
||||
dat4(i)=correct(12-i)
|
||||
enddo
|
||||
|
||||
|
||||
msg=' '
|
||||
! if(nhard.ge.0) then
|
||||
if(nhard.ge.0 .and. nhard.le.42 .and. nsoft.le.32 .and. &
|
||||
(nhard+nsoft).le.73) then
|
||||
call unpackmsg(dat4,msg) !Unpack the user message
|
||||
if(msg.eq.'VK7MO K1JT FN20 ') then
|
||||
ngood=ngood+1
|
||||
do k=0,62
|
||||
j=indx(k)
|
||||
i=(62-j)
|
||||
p1=mrprob(i)/255.0 + 1.e-10
|
||||
p2=mr2prob(i)/255.0
|
||||
ii=k/8
|
||||
jj=7.9999*p2/p1
|
||||
ns(ii,jj)=ns(ii,jj)+1
|
||||
if(correct(j).eq.mrsym(i)) then
|
||||
np1(ii,jj)=np1(ii,jj)+1
|
||||
else
|
||||
np0(ii,jj)=np0(ii,jj)+1
|
||||
endif
|
||||
if(correct(j).eq.mr2sym(i)) np2(ii,jj)=np2(ii,jj)+1
|
||||
enddo
|
||||
else
|
||||
nbad=nbad+1
|
||||
endif
|
||||
endif
|
||||
fgood=float(ngood)/ndone
|
||||
fbad=float(nbad)/ndone
|
||||
|
||||
nboth=nhard+nsoft
|
||||
if(nhard.lt.0) then
|
||||
nsoft=99
|
||||
nera=99
|
||||
nboth=99
|
||||
endif
|
||||
write(*,1010) ndone,fgood,fbad,ncandidates,nhard,nsoft,nera,nboth, &
|
||||
ntry,tt,msg
|
||||
write(32,1010) ndone,fgood,fbad,ncandidates,nhard,nsoft,nera,nboth, &
|
||||
ntry,tt,msg
|
||||
1010 format(i4,2f7.3,i7,4i3,i8,f8.1,1x,a22)
|
||||
flush(32)
|
||||
|
||||
if(msg.eq.'VK7MO K1JT FN20 ') then
|
||||
write(33,1012) ndone,ngood,nbad,ntry,log10(float(1+ntry))
|
||||
1012 format(4i8,f8.3)
|
||||
flush(33)
|
||||
endif
|
||||
|
||||
rewind 40
|
||||
write(40,1080)
|
||||
1080 format('Totals:')
|
||||
write(40,1090) ns
|
||||
1090 format(8i7)
|
||||
write(40,1091)
|
||||
1091 format(/'error:')
|
||||
write(40,1090) np0
|
||||
write(40,1092)
|
||||
1092 format(/'sym = mrsym:')
|
||||
write(40,1090) np1
|
||||
write(40,1093)
|
||||
1093 format(/'sym = mr2sym:')
|
||||
write(40,1090) np2
|
||||
|
||||
write(40,1095)
|
||||
1095 format(/'Probability of error:')
|
||||
perr=nint(100.0*float(np0)/(ns+0.001))
|
||||
write(40,1096) perr
|
||||
1096 format(8i7)
|
||||
|
||||
write(40,1097)
|
||||
1097 format(/'P(mr2 correct | mr not correct) :')
|
||||
pmr2=nint(100.0*float(np2)/(np0+0.001))
|
||||
write(40,1096) pmr2
|
||||
flush(40)
|
||||
|
||||
return
|
||||
end subroutine extract2
|
||||
@@ -0,0 +1,64 @@
|
||||
program fmtave
|
||||
|
||||
! Average groups of frequency-calibration measurements.
|
||||
|
||||
implicit real*8 (a-h,o-z)
|
||||
character infile*80
|
||||
character*8 cutc,cutc1
|
||||
|
||||
nargs=iargc()
|
||||
if(nargs.ne.1) then
|
||||
print*,'Usage: fmtave <infile>'
|
||||
print*,'Example: fmtave fmt.all'
|
||||
go to 999
|
||||
endif
|
||||
call getarg(1,infile)
|
||||
|
||||
open(10,file=infile,status='old')
|
||||
open(12,file='fmtave.out',status='unknown')
|
||||
|
||||
write(*,1000)
|
||||
1000 format(' Freq DF CAL N rms UTC Call'/ &
|
||||
' (kHz) (Hz) ? (Hz)'/ &
|
||||
'----------------------------------------------------')
|
||||
nkhz0=0
|
||||
sum=0.d0
|
||||
sumsq=0.d0
|
||||
n=0
|
||||
do i=1,99999
|
||||
read(10,*,end=10) cutc,nkHz,ncal,noffset,faudio,df,dblevel,snr
|
||||
if((nkHz.ne.nkHz0) .and. i.ne.1) then
|
||||
ave=sum/n
|
||||
rms=0.d0
|
||||
if(n.gt.1) then
|
||||
rms=sqrt(abs(sumsq - sum*sum/n)/(n-1.d0))
|
||||
endif
|
||||
fMHz=0.001d0*nkHz0
|
||||
write(*,1010) fMHz,ave,ncal0,n,rms,cutc1
|
||||
write(12,1010) fMHz,ave,ncal0,n,rms,cutc1
|
||||
1010 format(f8.3,f9.3,i4,i5,f8.2,2x,a8,2x,a6)
|
||||
sum=0.d0
|
||||
sumsq=0.d0
|
||||
n=0
|
||||
endif
|
||||
dial_error=faudio-noffset
|
||||
sum=sum + dial_error
|
||||
sumsq=sumsq + dial_error**2
|
||||
n=n+1
|
||||
if(n.eq.1) then
|
||||
cutc1=cutc
|
||||
ncal0=ncal
|
||||
endif
|
||||
nkHz0=nkHz
|
||||
enddo
|
||||
|
||||
10 ave=sum/n
|
||||
rms=0.d0
|
||||
if(n.gt.0) then
|
||||
rms=sqrt((sumsq - sum*sum/n)/(n-1.d0))
|
||||
endif
|
||||
fMHz=0.001d0*nkHz
|
||||
write(*,1010) fMHz,ave,ncal,n,rms,cutc1
|
||||
write(12,1010) fMHz,ave,ncal,n,rms,cutc1
|
||||
|
||||
999 end program fmtave
|
||||
@@ -0,0 +1,34 @@
|
||||
// Status=review
|
||||
|
||||
Download and execute the package file {win32}, following these
|
||||
instructions:
|
||||
|
||||
- Install _WSJT-X_ into its own directory, for example `C:\WSJTX` or
|
||||
`C:\WSJT\WSJTX`, rather than the conventional location
|
||||
`C:\Program Files\WSJTX`.
|
||||
|
||||
- All program files relating to _WSJT-X_ will be stored in the chosen
|
||||
installation directory and its subdirectories.
|
||||
|
||||
- Logs and other writeable files will normally be found in the
|
||||
directory +
|
||||
`C:\Users\<username>\AppData\Local\WSJT-X`.
|
||||
|
||||
TIP: Your computer may be configured so that this directory is
|
||||
"`invisible`". It's there, however, and accessible. An alternative
|
||||
(shortcut) directory name is `%LOCALAPPDATA%\WSJT-X\`.
|
||||
|
||||
- The built-in Windows facility for time synchronization is usually
|
||||
not adequate. We recommend the program _Meinberg NTP_ (see {ntpsetup}
|
||||
for downloading and installation instructions) or _Dimension 4_ from
|
||||
{dimension4}.
|
||||
|
||||
- _WSJT-X_ expects your sound card to do its raw sampling at 48000 Hz.
|
||||
To ensure that this will be so when running under recent versions of
|
||||
Windows, open the system's *Sound* control panel and select in turn the
|
||||
*Recording* and *Playback* tabs. Click on *Properties*, then
|
||||
*Advanced*, and select *16 bit, 48000 Hz (DVD Quality)*.
|
||||
|
||||
- You can uninstall _WSJT-X_ by clicking its *Uninstall* link in the
|
||||
Windows *Start* menu, or by using *Uninstall a Program* on the
|
||||
Windows Control Panel.
|
||||
@@ -0,0 +1,32 @@
|
||||
/*
|
||||
* sleep.h 1.0 02/03/10
|
||||
*
|
||||
* Defines cross-platform sleep, usleep, etc.
|
||||
*
|
||||
* By Wu Yongwei
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _SLEEP_H
|
||||
#define _SLEEP_H
|
||||
|
||||
#ifdef _WIN32
|
||||
# if defined(_NEED_SLEEP_ONLY) && (defined(_MSC_VER) || defined(__MINGW32__))
|
||||
# include <stdlib.h>
|
||||
# define sleep(t) _sleep((t) * 1000)
|
||||
# else
|
||||
# include <windows.h>
|
||||
# define sleep(t) Sleep((t) * 1000)
|
||||
# endif
|
||||
# ifndef _NEED_SLEEP_ONLY
|
||||
# define msleep(t) Sleep(t)
|
||||
# define usleep(t) Sleep((t) / 1000)
|
||||
# endif
|
||||
#else
|
||||
# include <unistd.h>
|
||||
# ifndef _NEED_SLEEP_ONLY
|
||||
# define msleep(t) usleep((t) * 1000)
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#endif /* _SLEEP_H */
|
||||
@@ -0,0 +1,350 @@
|
||||
/**
|
||||
* \file size.hpp
|
||||
*
|
||||
* \brief The family of \c size operations.
|
||||
*
|
||||
* Copyright (c) 2009-2010, Marco Guazzone
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
* \author Marco Guazzone, marco.guazzone@gmail.com
|
||||
*/
|
||||
|
||||
#ifndef BOOST_NUMERIC_UBLAS_OPERATION_SIZE_HPP
|
||||
#define BOOST_NUMERIC_UBLAS_OPERATION_SIZE_HPP
|
||||
|
||||
|
||||
#include <boost/mpl/has_xxx.hpp>
|
||||
#include <boost/mpl/if.hpp>
|
||||
#include <boost/numeric/ublas/detail/config.hpp>
|
||||
#include <boost/numeric/ublas/expression_types.hpp>
|
||||
#include <boost/numeric/ublas/fwd.hpp>
|
||||
#include <boost/numeric/ublas/tags.hpp>
|
||||
#include <boost/numeric/ublas/traits.hpp>
|
||||
#include <boost/utility/enable_if.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
|
||||
namespace boost { namespace numeric { namespace ublas {
|
||||
|
||||
namespace detail { namespace /*<unnamed>*/ {
|
||||
|
||||
/// Define a \c has_size_type trait class.
|
||||
BOOST_MPL_HAS_XXX_TRAIT_DEF(size_type)
|
||||
|
||||
|
||||
/**
|
||||
* \brief Wrapper type-traits used in \c boost::lazy_enabled_if for getting the
|
||||
* size type (see below).
|
||||
* \tparam VectorT A vector type.
|
||||
*/
|
||||
template <typename VectorT>
|
||||
struct vector_size_type
|
||||
{
|
||||
/// The size type.
|
||||
typedef typename vector_traits<VectorT>::size_type type;
|
||||
};
|
||||
|
||||
/**
|
||||
* \brief Wrapper type-traits used in \c boost::lazy_enabled_if for getting the
|
||||
* size type (see below).
|
||||
* \tparam MatrixT A matrix type.
|
||||
*/
|
||||
template <typename MatrixT>
|
||||
struct matrix_size_type
|
||||
{
|
||||
/// The size type.
|
||||
typedef typename matrix_traits<MatrixT>::size_type type;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Auxiliary class for computing the size of the given dimension for
|
||||
* a container of the given category.
|
||||
* \tparam Dim The dimension number (starting from 1).
|
||||
* \tparam CategoryT The category type (e.g., vector_tag).
|
||||
*/
|
||||
template <std::size_t Dim, typename CategoryT>
|
||||
struct size_by_dim_impl;
|
||||
|
||||
|
||||
/**
|
||||
* \brief Auxiliary class for computing the size of the given dimension for
|
||||
* a container of the given category and with the given orientation.
|
||||
* \tparam Dim The dimension number (starting from 1).
|
||||
* \tparam CategoryT The category type (e.g., vector_tag).
|
||||
* \tparam OrientationT The orientation category type (e.g., row_major_tag).
|
||||
*/
|
||||
template <typename TagT, typename CategoryT, typename OrientationT>
|
||||
struct size_by_tag_impl;
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_dim_impl for computing the size of a
|
||||
* vector.
|
||||
*/
|
||||
template <>
|
||||
struct size_by_dim_impl<1, vector_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the size of the given vector.
|
||||
* \tparam ExprT A vector expression type.
|
||||
* \pre ExprT must be a model of VectorExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename vector_traits<ExprT>::size_type apply(vector_expression<ExprT> const& ve)
|
||||
{
|
||||
return ve().size();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_dim_impl for computing the number of
|
||||
* rows of a matrix
|
||||
*/
|
||||
template <>
|
||||
struct size_by_dim_impl<1, matrix_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of rows of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size1();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_dim_impl for computing the number of
|
||||
* columns of a matrix
|
||||
*/
|
||||
template <>
|
||||
struct size_by_dim_impl<2, matrix_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of columns of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
* major dimension of a row-major oriented matrix.
|
||||
*/
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::major, matrix_tag, row_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of rows of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size1();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
* minor dimension of a row-major oriented matrix.
|
||||
*/
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::minor, matrix_tag, row_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of columns of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
* leading dimension of a row-major oriented matrix.
|
||||
*/
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::leading, matrix_tag, row_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of columns of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
/// major dimension of a column-major oriented matrix.
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::major, matrix_tag, column_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of columns of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
/// minor dimension of a column-major oriented matrix.
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::minor, matrix_tag, column_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of rows of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size1();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
/// leading dimension of a column-major oriented matrix.
|
||||
template <>
|
||||
struct size_by_tag_impl<tag::leading, matrix_tag, column_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Compute the number of rows of the given matrix.
|
||||
* \tparam ExprT A matrix expression type.
|
||||
* \pre ExprT must be a model of MatrixExpression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
static typename matrix_traits<ExprT>::size_type apply(matrix_expression<ExprT> const& me)
|
||||
{
|
||||
return me().size1();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c size_by_tag_impl for computing the size of the
|
||||
/// given dimension of a unknown oriented expression.
|
||||
template <typename TagT, typename CategoryT>
|
||||
struct size_by_tag_impl<TagT, CategoryT, unknown_orientation_tag>: size_by_tag_impl<TagT, CategoryT, row_major_tag>
|
||||
{
|
||||
// Empty
|
||||
};
|
||||
|
||||
}} // Namespace detail::<unnamed>
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return the number of columns.
|
||||
* \tparam VectorExprT A type which models the vector expression concept.
|
||||
* \param ve A vector expression.
|
||||
* \return The length of the input vector expression.
|
||||
*/
|
||||
template <typename VectorExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename ::boost::lazy_enable_if_c<
|
||||
detail::has_size_type<VectorExprT>::value,
|
||||
detail::vector_size_type<VectorExprT>
|
||||
>::type size(vector_expression<VectorExprT> const& ve)
|
||||
{
|
||||
return ve().size();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return the size of the given dimension for the given vector
|
||||
* expression.
|
||||
* \tparam Dim The dimension number (starting from 1).
|
||||
* \tparam VectorExprT A vector expression type.
|
||||
* \param ve A vector expression.
|
||||
* \return The length of the input vector expression.
|
||||
*/
|
||||
template <std::size_t Dim, typename VectorExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename vector_traits<VectorExprT>::size_type size(vector_expression<VectorExprT> const& ve)
|
||||
{
|
||||
return detail::size_by_dim_impl<Dim, vector_tag>::apply(ve);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return the size of the given dimension for the given matrix
|
||||
* expression.
|
||||
* \tparam Dim The dimension number (starting from 1).
|
||||
* \tparam MatrixExprT A matrix expression type.
|
||||
* \param e A matrix expression.
|
||||
* \return The size of the input matrix expression associated to the dimension
|
||||
* \a Dim.
|
||||
*/
|
||||
template <std::size_t Dim, typename MatrixExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename matrix_traits<MatrixExprT>::size_type size(matrix_expression<MatrixExprT> const& me)
|
||||
{
|
||||
return detail::size_by_dim_impl<Dim, matrix_tag>::apply(me);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return the size of the given dimension tag for the given matrix
|
||||
* expression.
|
||||
* \tparam TagT The dimension tag type (e.g., tag::major).
|
||||
* \tparam MatrixExprT A matrix expression type.
|
||||
* \param e A matrix expression.
|
||||
* \return The size of the input matrix expression associated to the dimension
|
||||
* tag \a TagT.
|
||||
*/
|
||||
template <typename TagT, typename MatrixExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename ::boost::lazy_enable_if_c<
|
||||
detail::has_size_type<MatrixExprT>::value,
|
||||
detail::matrix_size_type<MatrixExprT>
|
||||
>::type size(matrix_expression<MatrixExprT> const& me)
|
||||
{
|
||||
return detail::size_by_tag_impl<TagT, matrix_tag, typename matrix_traits<MatrixExprT>::orientation_category>::apply(me);
|
||||
}
|
||||
|
||||
}}} // Namespace boost::numeric::ublas
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_UBLAS_OPERATION_SIZE_HPP
|
||||
@@ -0,0 +1,36 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// Use, modification and distribution are subject to 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)
|
||||
//
|
||||
// This file is machine generated, do not edit by hand
|
||||
|
||||
// Polynomial evaluation using Horners rule
|
||||
#ifndef BOOST_MATH_TOOLS_POLY_EVAL_2_HPP
|
||||
#define BOOST_MATH_TOOLS_POLY_EVAL_2_HPP
|
||||
|
||||
namespace boost{ namespace math{ namespace tools{ namespace detail{
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T*, const V&, const mpl::int_<0>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(0);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V&, const mpl::int_<1>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[0]);
|
||||
}
|
||||
|
||||
template <class T, class V>
|
||||
inline V evaluate_polynomial_c_imp(const T* a, const V& x, const mpl::int_<2>*) BOOST_MATH_NOEXCEPT(V)
|
||||
{
|
||||
return static_cast<V>(a[1] * x + a[0]);
|
||||
}
|
||||
|
||||
|
||||
}}}} // namespaces
|
||||
|
||||
#endif // include guard
|
||||
|
||||
@@ -0,0 +1,376 @@
|
||||
// Copyright (C) 2005-2006 Douglas Gregor <doug.gregor@gmail.com>.
|
||||
// Copyright (C) 2004 The Trustees of Indiana University
|
||||
|
||||
// Use, modification and distribution is subject to 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)
|
||||
|
||||
// Authors: Douglas Gregor
|
||||
// Andrew Lumsdaine
|
||||
|
||||
// Message Passing Interface 1.1 -- Section 4.9.1. Reduce
|
||||
#ifndef BOOST_MPI_REDUCE_HPP
|
||||
#define BOOST_MPI_REDUCE_HPP
|
||||
|
||||
#include <boost/mpi/exception.hpp>
|
||||
#include <boost/mpi/datatype.hpp>
|
||||
|
||||
// For (de-)serializing sends and receives
|
||||
#include <boost/mpi/packed_oarchive.hpp>
|
||||
#include <boost/mpi/packed_iarchive.hpp>
|
||||
|
||||
// For packed_[io]archive sends and receives
|
||||
#include <boost/mpi/detail/point_to_point.hpp>
|
||||
|
||||
#include <boost/mpi/communicator.hpp>
|
||||
#include <boost/mpi/environment.hpp>
|
||||
#include <boost/mpi/detail/computation_tree.hpp>
|
||||
#include <boost/mpi/operations.hpp>
|
||||
#include <algorithm>
|
||||
#include <exception>
|
||||
#include <boost/assert.hpp>
|
||||
#include <boost/scoped_array.hpp>
|
||||
|
||||
namespace boost { namespace mpi {
|
||||
|
||||
|
||||
/************************************************************************
|
||||
* Implementation details *
|
||||
************************************************************************/
|
||||
namespace detail {
|
||||
/**********************************************************************
|
||||
* Simple reduction with MPI_Reduce *
|
||||
**********************************************************************/
|
||||
// We are reducing at the root for a type that has an associated MPI
|
||||
// datatype and operation, so we'll use MPI_Reduce directly.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n,
|
||||
T* out_values, Op /*op*/, int root, mpl::true_ /*is_mpi_op*/,
|
||||
mpl::true_/*is_mpi_datatype*/)
|
||||
{
|
||||
BOOST_MPI_CHECK_RESULT(MPI_Reduce,
|
||||
(const_cast<T*>(in_values), out_values, n,
|
||||
boost::mpi::get_mpi_datatype<T>(*in_values),
|
||||
(is_mpi_op<Op, T>::op()), root, comm));
|
||||
}
|
||||
|
||||
// We are reducing to the root for a type that has an associated MPI
|
||||
// datatype and operation, so we'll use MPI_Reduce directly.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n, Op /*op*/,
|
||||
int root, mpl::true_ /*is_mpi_op*/, mpl::true_/*is_mpi_datatype*/)
|
||||
{
|
||||
BOOST_MPI_CHECK_RESULT(MPI_Reduce,
|
||||
(const_cast<T*>(in_values), 0, n,
|
||||
boost::mpi::get_mpi_datatype<T>(*in_values),
|
||||
(is_mpi_op<Op, T>::op()), root, comm));
|
||||
}
|
||||
|
||||
/**********************************************************************
|
||||
* User-defined reduction with MPI_Reduce *
|
||||
**********************************************************************/
|
||||
|
||||
// We are reducing at the root for a type that has an associated MPI
|
||||
// datatype but with a custom operation. We'll use MPI_Reduce
|
||||
// directly, but we'll need to create an MPI_Op manually.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n,
|
||||
T* out_values, Op op, int root, mpl::false_ /*is_mpi_op*/,
|
||||
mpl::true_/*is_mpi_datatype*/)
|
||||
{
|
||||
user_op<Op, T> mpi_op(op);
|
||||
BOOST_MPI_CHECK_RESULT(MPI_Reduce,
|
||||
(const_cast<T*>(in_values), out_values, n,
|
||||
boost::mpi::get_mpi_datatype<T>(*in_values),
|
||||
mpi_op.get_mpi_op(), root, comm));
|
||||
}
|
||||
|
||||
// We are reducing to the root for a type that has an associated MPI
|
||||
// datatype but with a custom operation. We'll use MPI_Reduce
|
||||
// directly, but we'll need to create an MPI_Op manually.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n, Op op,
|
||||
int root, mpl::false_/*is_mpi_op*/, mpl::true_/*is_mpi_datatype*/)
|
||||
{
|
||||
user_op<Op, T> mpi_op(op);
|
||||
BOOST_MPI_CHECK_RESULT(MPI_Reduce,
|
||||
(const_cast<T*>(in_values), 0, n,
|
||||
boost::mpi::get_mpi_datatype<T>(*in_values),
|
||||
mpi_op.get_mpi_op(), root, comm));
|
||||
}
|
||||
|
||||
/**********************************************************************
|
||||
* User-defined, tree-based reduction for non-MPI data types *
|
||||
**********************************************************************/
|
||||
|
||||
// Commutative reduction
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
tree_reduce_impl(const communicator& comm, const T* in_values, int n,
|
||||
T* out_values, Op op, int root,
|
||||
mpl::true_ /*is_commutative*/)
|
||||
{
|
||||
std::copy(in_values, in_values + n, out_values);
|
||||
|
||||
int size = comm.size();
|
||||
int rank = comm.rank();
|
||||
|
||||
// The computation tree we will use.
|
||||
detail::computation_tree tree(rank, size, root);
|
||||
|
||||
int tag = environment::collectives_tag();
|
||||
|
||||
MPI_Status status;
|
||||
int children = 0;
|
||||
for (int child = tree.child_begin();
|
||||
children < tree.branching_factor() && child != root;
|
||||
++children, child = (child + 1) % size) {
|
||||
// Receive archive
|
||||
packed_iarchive ia(comm);
|
||||
detail::packed_archive_recv(comm, child, tag, ia, status);
|
||||
|
||||
T incoming;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
ia >> incoming;
|
||||
out_values[i] = op(out_values[i], incoming);
|
||||
}
|
||||
}
|
||||
|
||||
// For non-roots, send the result to the parent.
|
||||
if (tree.parent() != rank) {
|
||||
packed_oarchive oa(comm);
|
||||
for (int i = 0; i < n; ++i)
|
||||
oa << out_values[i];
|
||||
detail::packed_archive_send(comm, tree.parent(), tag, oa);
|
||||
}
|
||||
}
|
||||
|
||||
// Commutative reduction from a non-root.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
tree_reduce_impl(const communicator& comm, const T* in_values, int n, Op op,
|
||||
int root, mpl::true_ /*is_commutative*/)
|
||||
{
|
||||
scoped_array<T> results(new T[n]);
|
||||
detail::tree_reduce_impl(comm, in_values, n, results.get(), op, root,
|
||||
mpl::true_());
|
||||
}
|
||||
|
||||
// Non-commutative reduction
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
tree_reduce_impl(const communicator& comm, const T* in_values, int n,
|
||||
T* out_values, Op op, int root,
|
||||
mpl::false_ /*is_commutative*/)
|
||||
{
|
||||
int tag = environment::collectives_tag();
|
||||
|
||||
int left_child = root / 2;
|
||||
int right_child = (root + comm.size()) / 2;
|
||||
|
||||
MPI_Status status;
|
||||
if (left_child != root) {
|
||||
// Receive value from the left child and merge it with the value
|
||||
// we had incoming.
|
||||
packed_iarchive ia(comm);
|
||||
detail::packed_archive_recv(comm, left_child, tag, ia, status);
|
||||
T incoming;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
ia >> incoming;
|
||||
out_values[i] = op(incoming, in_values[i]);
|
||||
}
|
||||
} else {
|
||||
// There was no left value, so copy our incoming value.
|
||||
std::copy(in_values, in_values + n, out_values);
|
||||
}
|
||||
|
||||
if (right_child != root) {
|
||||
// Receive value from the right child and merge it with the
|
||||
// value we had incoming.
|
||||
packed_iarchive ia(comm);
|
||||
detail::packed_archive_recv(comm, right_child, tag, ia, status);
|
||||
T incoming;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
ia >> incoming;
|
||||
out_values[i] = op(out_values[i], incoming);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Non-commutative reduction from a non-root.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
tree_reduce_impl(const communicator& comm, const T* in_values, int n, Op op,
|
||||
int root, mpl::false_ /*is_commutative*/)
|
||||
{
|
||||
int size = comm.size();
|
||||
int rank = comm.rank();
|
||||
|
||||
int tag = environment::collectives_tag();
|
||||
|
||||
// Determine our parents and children in the commutative binary
|
||||
// computation tree.
|
||||
int grandparent = root;
|
||||
int parent = root;
|
||||
int left_bound = 0;
|
||||
int right_bound = size;
|
||||
int left_child, right_child;
|
||||
do {
|
||||
left_child = (left_bound + parent) / 2;
|
||||
right_child = (parent + right_bound) / 2;
|
||||
|
||||
if (rank < parent) {
|
||||
// Go left.
|
||||
grandparent = parent;
|
||||
right_bound = parent;
|
||||
parent = left_child;
|
||||
} else if (rank > parent) {
|
||||
// Go right.
|
||||
grandparent = parent;
|
||||
left_bound = parent + 1;
|
||||
parent = right_child;
|
||||
} else {
|
||||
// We've found the parent
|
||||
break;
|
||||
}
|
||||
} while (true);
|
||||
|
||||
// Our parent is the grandparent of our children. This is a slight
|
||||
// abuse of notation, but it makes the send-to-parent below make
|
||||
// more sense.
|
||||
parent = grandparent;
|
||||
|
||||
MPI_Status status;
|
||||
scoped_array<T> out_values(new T[n]);
|
||||
if (left_child != rank) {
|
||||
// Receive value from the left child and merge it with the value
|
||||
// we had incoming.
|
||||
packed_iarchive ia(comm);
|
||||
detail::packed_archive_recv(comm, left_child, tag, ia, status);
|
||||
T incoming;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
ia >> incoming;
|
||||
out_values[i] = op(incoming, in_values[i]);
|
||||
}
|
||||
} else {
|
||||
// There was no left value, so copy our incoming value.
|
||||
std::copy(in_values, in_values + n, out_values.get());
|
||||
}
|
||||
|
||||
if (right_child != rank) {
|
||||
// Receive value from the right child and merge it with the
|
||||
// value we had incoming.
|
||||
packed_iarchive ia(comm);
|
||||
detail::packed_archive_recv(comm, right_child, tag, ia, status);
|
||||
T incoming;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
ia >> incoming;
|
||||
out_values[i] = op(out_values[i], incoming);
|
||||
}
|
||||
}
|
||||
|
||||
// Send the combined value to our parent.
|
||||
packed_oarchive oa(comm);
|
||||
for (int i = 0; i < n; ++i)
|
||||
oa << out_values[i];
|
||||
detail::packed_archive_send(comm, parent, tag, oa);
|
||||
}
|
||||
|
||||
// We are reducing at the root for a type that has no associated MPI
|
||||
// datatype and operation, so we'll use a simple tree-based
|
||||
// algorithm.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n,
|
||||
T* out_values, Op op, int root, mpl::false_ /*is_mpi_op*/,
|
||||
mpl::false_ /*is_mpi_datatype*/)
|
||||
{
|
||||
detail::tree_reduce_impl(comm, in_values, n, out_values, op, root,
|
||||
is_commutative<Op, T>());
|
||||
}
|
||||
|
||||
// We are reducing to the root for a type that has no associated MPI
|
||||
// datatype and operation, so we'll use a simple tree-based
|
||||
// algorithm.
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce_impl(const communicator& comm, const T* in_values, int n, Op op,
|
||||
int root, mpl::false_ /*is_mpi_op*/,
|
||||
mpl::false_ /*is_mpi_datatype*/)
|
||||
{
|
||||
detail::tree_reduce_impl(comm, in_values, n, op, root,
|
||||
is_commutative<Op, T>());
|
||||
}
|
||||
} // end namespace detail
|
||||
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce(const communicator& comm, const T* in_values, int n, T* out_values,
|
||||
Op op, int root)
|
||||
{
|
||||
if (comm.rank() == root)
|
||||
detail::reduce_impl(comm, in_values, n, out_values, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
else
|
||||
detail::reduce_impl(comm, in_values, n, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
}
|
||||
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce(const communicator& comm, const T* in_values, int n, Op op, int root)
|
||||
{
|
||||
BOOST_ASSERT(comm.rank() != root);
|
||||
|
||||
detail::reduce_impl(comm, in_values, n, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
}
|
||||
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce(const communicator & comm, std::vector<T> const & in_values, Op op,
|
||||
int root)
|
||||
{
|
||||
reduce(comm, &in_values.front(), in_values.size(), op, root);
|
||||
}
|
||||
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce(const communicator & comm, std::vector<T> const & in_values,
|
||||
std::vector<T> & out_values, Op op, int root)
|
||||
{
|
||||
if (root == comm.rank()) out_values.resize(in_values.size());
|
||||
reduce(comm, &in_values.front(), in_values.size(), &out_values.front(), op,
|
||||
root);
|
||||
}
|
||||
|
||||
|
||||
template<typename T, typename Op>
|
||||
void
|
||||
reduce(const communicator& comm, const T& in_value, T& out_value, Op op,
|
||||
int root)
|
||||
{
|
||||
if (comm.rank() == root)
|
||||
detail::reduce_impl(comm, &in_value, 1, &out_value, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
else
|
||||
detail::reduce_impl(comm, &in_value, 1, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
}
|
||||
|
||||
template<typename T, typename Op>
|
||||
void reduce(const communicator& comm, const T& in_value, Op op, int root)
|
||||
{
|
||||
BOOST_ASSERT(comm.rank() != root);
|
||||
|
||||
detail::reduce_impl(comm, &in_value, 1, op, root,
|
||||
is_mpi_op<Op, T>(), is_mpi_datatype<T>());
|
||||
}
|
||||
|
||||
} } // end namespace boost::mpi
|
||||
|
||||
#endif // BOOST_MPI_REDUCE_HPP
|
||||
@@ -0,0 +1,24 @@
|
||||
// (C) Copyright John Maddock 2007.
|
||||
// Use, modification and distribution are subject to 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/type_traits for most recent version including documentation.
|
||||
|
||||
#ifndef BOOST_TT_IS_COMPLEX_HPP
|
||||
#define BOOST_TT_IS_COMPLEX_HPP
|
||||
|
||||
#include <complex>
|
||||
#include <boost/type_traits/integral_constant.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
template <class T> struct is_complex : public false_type {};
|
||||
template <class T> struct is_complex<const T > : public is_complex<T>{};
|
||||
template <class T> struct is_complex<volatile const T > : public is_complex<T>{};
|
||||
template <class T> struct is_complex<volatile T > : public is_complex<T>{};
|
||||
template <class T> struct is_complex<std::complex<T> > : public true_type{};
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif //BOOST_TT_IS_COMPLEX_HPP
|
||||
@@ -0,0 +1,79 @@
|
||||
#ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
|
||||
#define BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
// Copyright (c) 2008 Peter Dimov
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
#include <pthread.h>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
class spinlock
|
||||
{
|
||||
public:
|
||||
|
||||
pthread_mutex_t v_;
|
||||
|
||||
public:
|
||||
|
||||
bool try_lock()
|
||||
{
|
||||
return pthread_mutex_trylock( &v_ ) == 0;
|
||||
}
|
||||
|
||||
void lock()
|
||||
{
|
||||
pthread_mutex_lock( &v_ );
|
||||
}
|
||||
|
||||
void unlock()
|
||||
{
|
||||
pthread_mutex_unlock( &v_ );
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
class scoped_lock
|
||||
{
|
||||
private:
|
||||
|
||||
spinlock & sp_;
|
||||
|
||||
scoped_lock( scoped_lock const & );
|
||||
scoped_lock & operator=( scoped_lock const & );
|
||||
|
||||
public:
|
||||
|
||||
explicit scoped_lock( spinlock & sp ): sp_( sp )
|
||||
{
|
||||
sp.lock();
|
||||
}
|
||||
|
||||
~scoped_lock()
|
||||
{
|
||||
sp_.unlock();
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
} // namespace boost
|
||||
|
||||
#define BOOST_DETAIL_SPINLOCK_INIT { PTHREAD_MUTEX_INITIALIZER }
|
||||
|
||||
#endif // #ifndef BOOST_SMART_PTR_DETAIL_SPINLOCK_PT_HPP_INCLUDED
|
||||
@@ -0,0 +1,107 @@
|
||||
#ifndef BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMPL_HPP_INCLUDED
|
||||
#define BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMPL_HPP_INCLUDED
|
||||
|
||||
//
|
||||
// Copyright 2015 Peter Dimov
|
||||
//
|
||||
// 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
|
||||
//
|
||||
|
||||
#include <boost/type_traits/detail/common_arithmetic_type.hpp>
|
||||
#include <boost/type_traits/detail/composite_pointer_type.hpp>
|
||||
#include <boost/type_traits/detail/composite_member_pointer_type.hpp>
|
||||
#include <boost/type_traits/type_identity.hpp>
|
||||
#include <boost/type_traits/is_class.hpp>
|
||||
#include <boost/type_traits/is_union.hpp>
|
||||
#include <boost/type_traits/is_convertible.hpp>
|
||||
#include <boost/type_traits/is_pointer.hpp>
|
||||
#include <boost/type_traits/is_member_pointer.hpp>
|
||||
#include <boost/type_traits/conditional.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace type_traits_detail
|
||||
{
|
||||
|
||||
// the arguments to common_type_impl have already been passed through decay<>
|
||||
|
||||
template<class T, class U> struct common_type_impl;
|
||||
|
||||
// same type
|
||||
|
||||
template<class T> struct common_type_impl<T, T>
|
||||
{
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
// one of the operands is a class type, try conversions in both directions
|
||||
|
||||
template<class T, class U> struct ct_class
|
||||
{
|
||||
BOOST_STATIC_CONSTANT( bool, ct = boost::is_class<T>::value || boost::is_union<T>::value );
|
||||
BOOST_STATIC_CONSTANT( bool, cu = boost::is_class<U>::value || boost::is_union<U>::value );
|
||||
|
||||
BOOST_STATIC_CONSTANT( bool, value = ct || cu );
|
||||
};
|
||||
|
||||
template<class T, class U> struct common_type_impl3;
|
||||
|
||||
template<class T, class U> struct common_type_class: public boost::conditional<
|
||||
|
||||
boost::is_convertible<T, U>::value && !boost::is_convertible<U, T>::value,
|
||||
boost::type_identity<U>,
|
||||
|
||||
typename boost::conditional<
|
||||
|
||||
boost::is_convertible<U, T>::value && !boost::is_convertible<T, U>::value,
|
||||
boost::type_identity<T>,
|
||||
|
||||
common_type_impl3<T, U>
|
||||
>::type
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
template<class T, class U> struct common_type_impl: public boost::conditional<
|
||||
ct_class<T, U>::value,
|
||||
common_type_class<T, U>,
|
||||
common_type_impl3<T, U> >::type
|
||||
{
|
||||
};
|
||||
|
||||
// pointers
|
||||
|
||||
template<class T, class U> struct common_type_impl4;
|
||||
|
||||
template<class T, class U> struct common_type_impl3: public boost::conditional<
|
||||
boost::is_pointer<T>::value || boost::is_pointer<U>::value,
|
||||
composite_pointer_type<T, U>,
|
||||
common_type_impl4<T, U> >::type
|
||||
{
|
||||
};
|
||||
|
||||
// pointers to members
|
||||
|
||||
template<class T, class U> struct common_type_impl5;
|
||||
|
||||
template<class T, class U> struct common_type_impl4: public boost::conditional<
|
||||
boost::is_member_pointer<T>::value || boost::is_member_pointer<U>::value,
|
||||
composite_member_pointer_type<T, U>,
|
||||
common_type_impl5<T, U> >::type
|
||||
{
|
||||
};
|
||||
|
||||
// arithmetic types (including class types w/ conversions to arithmetic and enums)
|
||||
|
||||
template<class T, class U> struct common_type_impl5: public common_arithmetic_type<T, U>
|
||||
{
|
||||
};
|
||||
|
||||
} // namespace type_traits_detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_TYPE_TRAITS_DETAIL_COMMON_TYPE_IMPL_HPP_INCLUDED
|
||||
@@ -0,0 +1,148 @@
|
||||
// Boost pow.hpp header file
|
||||
// Computes a power with exponent known at compile-time
|
||||
|
||||
// (C) Copyright Bruno Lalande 2008.
|
||||
// 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 for updates, documentation, and revision history.
|
||||
|
||||
|
||||
#ifndef BOOST_MATH_POW_HPP
|
||||
#define BOOST_MATH_POW_HPP
|
||||
|
||||
|
||||
#include <boost/math/special_functions/math_fwd.hpp>
|
||||
#include <boost/math/policies/policy.hpp>
|
||||
#include <boost/math/policies/error_handling.hpp>
|
||||
#include <boost/math/tools/promotion.hpp>
|
||||
#include <boost/mpl/greater_equal.hpp>
|
||||
|
||||
|
||||
namespace boost {
|
||||
namespace math {
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(push)
|
||||
#pragma warning(disable:4702) // Unreachable code, only triggered in release mode and /W4
|
||||
#endif
|
||||
|
||||
namespace detail {
|
||||
|
||||
|
||||
template <int N, int M = N%2>
|
||||
struct positive_power
|
||||
{
|
||||
template <typename T>
|
||||
static T result(T base)
|
||||
{
|
||||
T power = positive_power<N/2>::result(base);
|
||||
return power * power;
|
||||
}
|
||||
};
|
||||
|
||||
template <int N>
|
||||
struct positive_power<N, 1>
|
||||
{
|
||||
template <typename T>
|
||||
static T result(T base)
|
||||
{
|
||||
T power = positive_power<N/2>::result(base);
|
||||
return base * power * power;
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct positive_power<1, 1>
|
||||
{
|
||||
template <typename T>
|
||||
static T result(T base){ return base; }
|
||||
};
|
||||
|
||||
|
||||
template <int N, bool>
|
||||
struct power_if_positive
|
||||
{
|
||||
template <typename T, class Policy>
|
||||
static T result(T base, const Policy&)
|
||||
{ return positive_power<N>::result(base); }
|
||||
};
|
||||
|
||||
template <int N>
|
||||
struct power_if_positive<N, false>
|
||||
{
|
||||
template <typename T, class Policy>
|
||||
static T result(T base, const Policy& policy)
|
||||
{
|
||||
if (base == 0)
|
||||
{
|
||||
return policies::raise_overflow_error<T>(
|
||||
"boost::math::pow(%1%)",
|
||||
"Attempted to compute a negative power of 0",
|
||||
policy
|
||||
);
|
||||
}
|
||||
|
||||
return T(1) / positive_power<-N>::result(base);
|
||||
}
|
||||
};
|
||||
|
||||
template <>
|
||||
struct power_if_positive<0, true>
|
||||
{
|
||||
template <typename T, class Policy>
|
||||
static T result(T base, const Policy& policy)
|
||||
{
|
||||
if (base == 0)
|
||||
{
|
||||
return policies::raise_indeterminate_result_error<T>(
|
||||
"boost::math::pow(%1%)",
|
||||
"The result of pow<0>(%1%) is undetermined",
|
||||
base,
|
||||
T(1),
|
||||
policy
|
||||
);
|
||||
}
|
||||
|
||||
return T(1);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
template <int N>
|
||||
struct select_power_if_positive
|
||||
{
|
||||
typedef typename mpl::greater_equal<
|
||||
mpl::int_<N>,
|
||||
mpl::int_<0>
|
||||
>::type is_positive;
|
||||
|
||||
typedef power_if_positive<N, is_positive::value> type;
|
||||
};
|
||||
|
||||
|
||||
} // namespace detail
|
||||
|
||||
|
||||
template <int N, typename T, class Policy>
|
||||
inline typename tools::promote_args<T>::type pow(T base, const Policy& policy)
|
||||
{
|
||||
typedef typename tools::promote_args<T>::type result_type;
|
||||
return detail::select_power_if_positive<N>::type::result(static_cast<result_type>(base), policy);
|
||||
}
|
||||
|
||||
|
||||
template <int N, typename T>
|
||||
inline typename tools::promote_args<T>::type pow(T base)
|
||||
{ return pow<N>(base, policies::policy<>()); }
|
||||
|
||||
#ifdef BOOST_MSVC
|
||||
#pragma warning(pop)
|
||||
#endif
|
||||
|
||||
} // namespace math
|
||||
} // namespace boost
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,30 @@
|
||||
subroutine genwspr(message,msgsent,itone)
|
||||
! Encode a WSPR message and generate the array of channel symbols.
|
||||
|
||||
character*22 message,msgsent
|
||||
parameter (MAXSYM=176)
|
||||
integer*1 symbol(MAXSYM)
|
||||
integer*1 data0(11)
|
||||
integer*4 itone(162)
|
||||
integer npr3(162)
|
||||
data npr3/ &
|
||||
1,1,0,0,0,0,0,0,1,0,0,0,1,1,1,0,0,0,1,0, &
|
||||
0,1,0,1,1,1,1,0,0,0,0,0,0,0,1,0,0,1,0,1, &
|
||||
0,0,0,0,0,0,1,0,1,1,0,0,1,1,0,1,0,0,0,1, &
|
||||
1,0,1,0,0,0,0,1,1,0,1,0,1,0,1,0,1,0,0,1, &
|
||||
0,0,1,0,1,1,0,0,0,1,1,0,1,0,1,0,0,0,1,0, &
|
||||
0,0,0,0,1,0,0,1,0,0,1,1,1,0,1,1,0,0,1,1, &
|
||||
0,1,0,0,0,1,1,1,0,0,0,0,0,1,0,1,0,0,1,1, &
|
||||
0,0,0,0,0,0,0,1,1,0,1,0,1,1,0,0,0,1,1,0, &
|
||||
0,0/
|
||||
|
||||
call wqencode(message,ntype,data0) !Source encoding
|
||||
call encode232(data0,162,symbol) !Convolutional encoding
|
||||
call inter_wspr(symbol,1) !Interleaving
|
||||
do i=1,162
|
||||
itone(i)=npr3(i) + 2*symbol(i)
|
||||
enddo
|
||||
msgsent=message !### To be fixed... ?? ###
|
||||
|
||||
return
|
||||
end subroutine genwspr
|
||||
@@ -0,0 +1,182 @@
|
||||
#ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
|
||||
#define BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
|
||||
|
||||
// MS compatible compilers support #pragma once
|
||||
|
||||
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
//
|
||||
// detail/sp_counted_base_gcc_mips.hpp - g++ on MIPS
|
||||
//
|
||||
// Copyright (c) 2009, Spirent Communications, Inc.
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
//
|
||||
// Lock-free algorithm by Alexander Terekhov
|
||||
//
|
||||
|
||||
#include <boost/detail/sp_typeinfo.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
namespace detail
|
||||
{
|
||||
|
||||
inline void atomic_increment( int * pw )
|
||||
{
|
||||
// ++*pw;
|
||||
|
||||
int tmp;
|
||||
|
||||
__asm__ __volatile__
|
||||
(
|
||||
"0:\n\t"
|
||||
".set push\n\t"
|
||||
".set mips2\n\t"
|
||||
"ll %0, %1\n\t"
|
||||
"addiu %0, 1\n\t"
|
||||
"sc %0, %1\n\t"
|
||||
".set pop\n\t"
|
||||
"beqz %0, 0b":
|
||||
"=&r"( tmp ), "=m"( *pw ):
|
||||
"m"( *pw )
|
||||
);
|
||||
}
|
||||
|
||||
inline int atomic_decrement( int * pw )
|
||||
{
|
||||
// return --*pw;
|
||||
|
||||
int rv, tmp;
|
||||
|
||||
__asm__ __volatile__
|
||||
(
|
||||
"0:\n\t"
|
||||
".set push\n\t"
|
||||
".set mips2\n\t"
|
||||
"ll %1, %2\n\t"
|
||||
"addiu %0, %1, -1\n\t"
|
||||
"sc %0, %2\n\t"
|
||||
".set pop\n\t"
|
||||
"beqz %0, 0b\n\t"
|
||||
"addiu %0, %1, -1":
|
||||
"=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
|
||||
"m"( *pw ):
|
||||
"memory"
|
||||
);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
inline int atomic_conditional_increment( int * pw )
|
||||
{
|
||||
// if( *pw != 0 ) ++*pw;
|
||||
// return *pw;
|
||||
|
||||
int rv, tmp;
|
||||
|
||||
__asm__ __volatile__
|
||||
(
|
||||
"0:\n\t"
|
||||
".set push\n\t"
|
||||
".set mips2\n\t"
|
||||
"ll %0, %2\n\t"
|
||||
"beqz %0, 1f\n\t"
|
||||
"addiu %1, %0, 1\n\t"
|
||||
"sc %1, %2\n\t"
|
||||
".set pop\n\t"
|
||||
"beqz %1, 0b\n\t"
|
||||
"addiu %0, %0, 1\n\t"
|
||||
"1:":
|
||||
"=&r"( rv ), "=&r"( tmp ), "=m"( *pw ):
|
||||
"m"( *pw ):
|
||||
"memory"
|
||||
);
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
class sp_counted_base
|
||||
{
|
||||
private:
|
||||
|
||||
sp_counted_base( sp_counted_base const & );
|
||||
sp_counted_base & operator= ( sp_counted_base const & );
|
||||
|
||||
int use_count_; // #shared
|
||||
int weak_count_; // #weak + (#shared != 0)
|
||||
|
||||
public:
|
||||
|
||||
sp_counted_base(): use_count_( 1 ), weak_count_( 1 )
|
||||
{
|
||||
}
|
||||
|
||||
virtual ~sp_counted_base() // nothrow
|
||||
{
|
||||
}
|
||||
|
||||
// dispose() is called when use_count_ drops to zero, to release
|
||||
// the resources managed by *this.
|
||||
|
||||
virtual void dispose() = 0; // nothrow
|
||||
|
||||
// destroy() is called when weak_count_ drops to zero.
|
||||
|
||||
virtual void destroy() // nothrow
|
||||
{
|
||||
delete this;
|
||||
}
|
||||
|
||||
virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
|
||||
virtual void * get_untyped_deleter() = 0;
|
||||
|
||||
void add_ref_copy()
|
||||
{
|
||||
atomic_increment( &use_count_ );
|
||||
}
|
||||
|
||||
bool add_ref_lock() // true on success
|
||||
{
|
||||
return atomic_conditional_increment( &use_count_ ) != 0;
|
||||
}
|
||||
|
||||
void release() // nothrow
|
||||
{
|
||||
if( atomic_decrement( &use_count_ ) == 0 )
|
||||
{
|
||||
dispose();
|
||||
weak_release();
|
||||
}
|
||||
}
|
||||
|
||||
void weak_add_ref() // nothrow
|
||||
{
|
||||
atomic_increment( &weak_count_ );
|
||||
}
|
||||
|
||||
void weak_release() // nothrow
|
||||
{
|
||||
if( atomic_decrement( &weak_count_ ) == 0 )
|
||||
{
|
||||
destroy();
|
||||
}
|
||||
}
|
||||
|
||||
long use_count() const // nothrow
|
||||
{
|
||||
return static_cast<int const volatile &>( use_count_ );
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace detail
|
||||
|
||||
} // namespace boost
|
||||
|
||||
#endif // #ifndef BOOST_DETAIL_SP_COUNTED_BASE_GCC_MIPS_HPP_INCLUDED
|
||||
@@ -0,0 +1,114 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
// Copyright Jaap Suter 2003
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/shift_right.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename Tag1
|
||||
, typename Tag2
|
||||
|
||||
, BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value
|
||||
, BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value
|
||||
>
|
||||
struct shift_right_impl
|
||||
: if_c<
|
||||
( tag1_ > tag2_ )
|
||||
, aux::cast2nd_impl< shift_right_impl< Tag1,Tag1 >,Tag1, Tag2 >
|
||||
, aux::cast1st_impl< shift_right_impl< Tag2,Tag2 >,Tag1, Tag2 >
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
/// for Digital Mars C++/compilers with no CTPS/TTP support
|
||||
template<> struct shift_right_impl< na,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct shift_right_impl< na,integral_c_tag >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct shift_right_impl< integral_c_tag,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename T > struct shift_right_tag
|
||||
: tag< T,na >
|
||||
{
|
||||
};
|
||||
|
||||
template<
|
||||
typename BOOST_MPL_AUX_NA_PARAM(N1)
|
||||
, typename BOOST_MPL_AUX_NA_PARAM(N2)
|
||||
>
|
||||
struct shift_right
|
||||
: aux::msvc_eti_base< typename apply_wrap2<
|
||||
shift_right_impl<
|
||||
typename shift_right_tag<N1>::type
|
||||
, typename shift_right_tag<N2>::type
|
||||
>
|
||||
, N1
|
||||
, N2
|
||||
>::type >::type
|
||||
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, shift_right, (N1, N2))
|
||||
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC2(2, 2, shift_right)
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
namespace aux {
|
||||
template< typename T, typename Shift, T n, Shift s >
|
||||
struct shift_right_wknd
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(T, value = (n >> s));
|
||||
typedef integral_c< T,value > type;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
template<>
|
||||
struct shift_right_impl< integral_c_tag,integral_c_tag >
|
||||
{
|
||||
template< typename N, typename S > struct apply
|
||||
: aux::shift_right_wknd<
|
||||
typename N::value_type
|
||||
, typename S::value_type
|
||||
, N::value
|
||||
, S::value
|
||||
>::type
|
||||
|
||||
{
|
||||
};
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,182 @@
|
||||
/*
|
||||
*
|
||||
* Copyright (c) 2004
|
||||
* John Maddock
|
||||
*
|
||||
* Use, modification and distribution are subject to 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)
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* LOCATION: see http://www.boost.org for most recent version.
|
||||
* FILE static_mutex.hpp
|
||||
* VERSION see <boost/version.hpp>
|
||||
* DESCRIPTION: Declares static_mutex lock type, there are three different
|
||||
* implementations: POSIX pthreads, WIN32 threads, and portable,
|
||||
* these are described in more detail below.
|
||||
*/
|
||||
|
||||
#ifndef BOOST_REGEX_STATIC_MUTEX_HPP
|
||||
#define BOOST_REGEX_STATIC_MUTEX_HPP
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/regex/config.hpp> // dll import/export options.
|
||||
|
||||
#ifdef BOOST_HAS_PTHREADS
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PTHREADS) && defined(PTHREAD_MUTEX_INITIALIZER)
|
||||
//
|
||||
// pthreads version:
|
||||
// simple wrap around a pthread_mutex_t initialized with
|
||||
// PTHREAD_MUTEX_INITIALIZER.
|
||||
//
|
||||
namespace boost{
|
||||
|
||||
class static_mutex;
|
||||
|
||||
#define BOOST_STATIC_MUTEX_INIT { PTHREAD_MUTEX_INITIALIZER, }
|
||||
|
||||
class BOOST_REGEX_DECL scoped_static_mutex_lock
|
||||
{
|
||||
public:
|
||||
scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
|
||||
~scoped_static_mutex_lock();
|
||||
inline bool locked()const
|
||||
{
|
||||
return m_have_lock;
|
||||
}
|
||||
inline operator void const*()const
|
||||
{
|
||||
return locked() ? this : 0;
|
||||
}
|
||||
void lock();
|
||||
void unlock();
|
||||
private:
|
||||
static_mutex& m_mutex;
|
||||
bool m_have_lock;
|
||||
};
|
||||
|
||||
class static_mutex
|
||||
{
|
||||
public:
|
||||
typedef scoped_static_mutex_lock scoped_lock;
|
||||
pthread_mutex_t m_mutex;
|
||||
};
|
||||
|
||||
} // namespace boost
|
||||
#elif defined(BOOST_HAS_WINTHREADS)
|
||||
//
|
||||
// Win32 version:
|
||||
// Use a 32-bit int as a lock, along with a test-and-set
|
||||
// implementation using InterlockedCompareExchange.
|
||||
//
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
|
||||
namespace boost{
|
||||
|
||||
class BOOST_REGEX_DECL scoped_static_mutex_lock;
|
||||
|
||||
class static_mutex
|
||||
{
|
||||
public:
|
||||
typedef scoped_static_mutex_lock scoped_lock;
|
||||
boost::int32_t m_mutex;
|
||||
};
|
||||
|
||||
#define BOOST_STATIC_MUTEX_INIT { 0, }
|
||||
|
||||
class BOOST_REGEX_DECL scoped_static_mutex_lock
|
||||
{
|
||||
public:
|
||||
scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
|
||||
~scoped_static_mutex_lock();
|
||||
operator void const*()const
|
||||
{
|
||||
return locked() ? this : 0;
|
||||
}
|
||||
bool locked()const
|
||||
{
|
||||
return m_have_lock;
|
||||
}
|
||||
void lock();
|
||||
void unlock();
|
||||
private:
|
||||
static_mutex& m_mutex;
|
||||
bool m_have_lock;
|
||||
scoped_static_mutex_lock(const scoped_static_mutex_lock&);
|
||||
scoped_static_mutex_lock& operator=(const scoped_static_mutex_lock&);
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
#else
|
||||
//
|
||||
// Portable version of a static mutex based on Boost.Thread library:
|
||||
// This has to use a single mutex shared by all instances of static_mutex
|
||||
// because boost::call_once doesn't alow us to pass instance information
|
||||
// down to the initialisation proceedure. In fact the initialisation routine
|
||||
// may need to be called more than once - but only once per instance.
|
||||
//
|
||||
// Since this preprocessor path is almost never taken, we hide these header
|
||||
// dependencies so that build tools don't find them.
|
||||
//
|
||||
#define BOOST_REGEX_H1 <boost/thread/once.hpp>
|
||||
#define BOOST_REGEX_H2 <boost/thread/recursive_mutex.hpp>
|
||||
#define BOOST_REGEX_H3 <boost/thread/lock_types.hpp>
|
||||
#include BOOST_REGEX_H1
|
||||
#include BOOST_REGEX_H2
|
||||
#include BOOST_REGEX_H3
|
||||
#undef BOOST_REGEX_H1
|
||||
#undef BOOST_REGEX_H2
|
||||
#undef BOOST_REGEX_H3
|
||||
|
||||
namespace boost{
|
||||
|
||||
class BOOST_REGEX_DECL scoped_static_mutex_lock;
|
||||
extern "C" BOOST_REGEX_DECL void boost_regex_free_static_mutex();
|
||||
|
||||
class BOOST_REGEX_DECL static_mutex
|
||||
{
|
||||
public:
|
||||
typedef scoped_static_mutex_lock scoped_lock;
|
||||
static void init();
|
||||
static boost::recursive_mutex* m_pmutex;
|
||||
static boost::once_flag m_once;
|
||||
};
|
||||
|
||||
#define BOOST_STATIC_MUTEX_INIT { }
|
||||
|
||||
class BOOST_REGEX_DECL scoped_static_mutex_lock
|
||||
{
|
||||
public:
|
||||
scoped_static_mutex_lock(static_mutex& mut, bool lk = true);
|
||||
~scoped_static_mutex_lock();
|
||||
operator void const*()const;
|
||||
bool locked()const;
|
||||
void lock();
|
||||
void unlock();
|
||||
private:
|
||||
boost::unique_lock<boost::recursive_mutex>* m_plock;
|
||||
bool m_have_lock;
|
||||
};
|
||||
|
||||
inline scoped_static_mutex_lock::operator void const*()const
|
||||
{
|
||||
return locked() ? this : 0;
|
||||
}
|
||||
|
||||
inline bool scoped_static_mutex_lock::locked()const
|
||||
{
|
||||
return m_have_lock;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
Copyright Rene Rivera 2008-2015
|
||||
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_PREDEF_OS_CYGWIN_H
|
||||
#define BOOST_PREDEF_OS_CYGWIN_H
|
||||
|
||||
#include <boost/predef/version_number.h>
|
||||
#include <boost/predef/make.h>
|
||||
|
||||
/*`
|
||||
[heading `BOOST_OS_CYGWIN`]
|
||||
|
||||
[@http://en.wikipedia.org/wiki/Cygwin Cygwin] evironment.
|
||||
|
||||
[table
|
||||
[[__predef_symbol__] [__predef_version__]]
|
||||
|
||||
[[`__CYGWIN__`] [__predef_detection__]]
|
||||
]
|
||||
*/
|
||||
|
||||
#define BOOST_OS_CYGWIN BOOST_VERSION_NUMBER_NOT_AVAILABLE
|
||||
|
||||
#if !defined(BOOST_PREDEF_DETAIL_OS_DETECTED) && ( \
|
||||
defined(__CYGWIN__) \
|
||||
)
|
||||
# undef BOOST_OS_CYGWIN
|
||||
# define BOOST_OS_CYGWIN BOOST_VERSION_NUMBER_AVAILABLE
|
||||
#endif
|
||||
|
||||
#if BOOST_OS_CYGWIN
|
||||
# define BOOST_OS_CYGWIN_AVAILABLE
|
||||
# include <boost/predef/detail/os_detected.h>
|
||||
#endif
|
||||
|
||||
#define BOOST_OS_CYGWIN_NAME "Cygwin"
|
||||
|
||||
#endif
|
||||
|
||||
#include <boost/predef/detail/test.h>
|
||||
BOOST_PREDEF_DECLARE_TEST(BOOST_OS_CYGWIN,BOOST_OS_CYGWIN_NAME)
|
||||
@@ -0,0 +1,19 @@
|
||||
|
||||
#ifndef BOOST_MPL_NEXT_HPP_INCLUDED
|
||||
#define BOOST_MPL_NEXT_HPP_INCLUDED
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2004
|
||||
//
|
||||
// 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/mpl for documentation.
|
||||
|
||||
// $Id$
|
||||
// $Date$
|
||||
// $Revision$
|
||||
|
||||
#include <boost/mpl/next_prior.hpp>
|
||||
|
||||
#endif // BOOST_MPL_NEXT_HPP_INCLUDED
|
||||
@@ -0,0 +1,660 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2001-2011 Joel de Guzman
|
||||
|
||||
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)
|
||||
|
||||
This is an auto-generated file. Do not edit!
|
||||
==============================================================================*/
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
struct void_;
|
||||
namespace result_of
|
||||
{
|
||||
template <
|
||||
typename T0 = void_ , typename T1 = void_ , typename T2 = void_ , typename T3 = void_ , typename T4 = void_ , typename T5 = void_ , typename T6 = void_ , typename T7 = void_ , typename T8 = void_ , typename T9 = void_ , typename T10 = void_ , typename T11 = void_ , typename T12 = void_ , typename T13 = void_ , typename T14 = void_ , typename T15 = void_ , typename T16 = void_ , typename T17 = void_ , typename T18 = void_ , typename T19 = void_ , typename T20 = void_ , typename T21 = void_ , typename T22 = void_ , typename T23 = void_ , typename T24 = void_ , typename T25 = void_ , typename T26 = void_ , typename T27 = void_ , typename T28 = void_ , typename T29 = void_ , typename T30 = void_ , typename T31 = void_ , typename T32 = void_ , typename T33 = void_ , typename T34 = void_ , typename T35 = void_ , typename T36 = void_ , typename T37 = void_ , typename T38 = void_ , typename T39 = void_
|
||||
, typename Extra = void_
|
||||
>
|
||||
struct deque_tie;
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0>
|
||||
struct deque_tie< T0 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0&>
|
||||
deque_tie(T0 & arg0)
|
||||
{
|
||||
return deque<T0&>(
|
||||
arg0);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1>
|
||||
struct deque_tie< T0 , T1 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1)
|
||||
{
|
||||
return deque<T0& , T1&>(
|
||||
arg0 , arg1);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
struct deque_tie< T0 , T1 , T2 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2)
|
||||
{
|
||||
return deque<T0& , T1& , T2&>(
|
||||
arg0 , arg1 , arg2);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3&>(
|
||||
arg0 , arg1 , arg2 , arg3);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , void_ , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , void_ , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , void_ , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , void_ , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , void_ , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , void_ , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , void_ , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38);
|
||||
}
|
||||
namespace result_of
|
||||
{
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39>
|
||||
struct deque_tie< T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , void_ >
|
||||
{
|
||||
typedef deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&> type;
|
||||
};
|
||||
}
|
||||
template <typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 , typename T12 , typename T13 , typename T14 , typename T15 , typename T16 , typename T17 , typename T18 , typename T19 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>
|
||||
deque_tie(T0 & arg0 , T1 & arg1 , T2 & arg2 , T3 & arg3 , T4 & arg4 , T5 & arg5 , T6 & arg6 , T7 & arg7 , T8 & arg8 , T9 & arg9 , T10 & arg10 , T11 & arg11 , T12 & arg12 , T13 & arg13 , T14 & arg14 , T15 & arg15 , T16 & arg16 , T17 & arg17 , T18 & arg18 , T19 & arg19 , T20 & arg20 , T21 & arg21 , T22 & arg22 , T23 & arg23 , T24 & arg24 , T25 & arg25 , T26 & arg26 , T27 & arg27 , T28 & arg28 , T29 & arg29 , T30 & arg30 , T31 & arg31 , T32 & arg32 , T33 & arg33 , T34 & arg34 , T35 & arg35 , T36 & arg36 , T37 & arg37 , T38 & arg38 , T39 & arg39)
|
||||
{
|
||||
return deque<T0& , T1& , T2& , T3& , T4& , T5& , T6& , T7& , T8& , T9& , T10& , T11& , T12& , T13& , T14& , T15& , T16& , T17& , T18& , T19& , T20& , T21& , T22& , T23& , T24& , T25& , T26& , T27& , T28& , T29& , T30& , T31& , T32& , T33& , T34& , T35& , T36& , T37& , T38& , T39&>(
|
||||
arg0 , arg1 , arg2 , arg3 , arg4 , arg5 , arg6 , arg7 , arg8 , arg9 , arg10 , arg11 , arg12 , arg13 , arg14 , arg15 , arg16 , arg17 , arg18 , arg19 , arg20 , arg21 , arg22 , arg23 , arg24 , arg25 , arg26 , arg27 , arg28 , arg29 , arg30 , arg31 , arg32 , arg33 , arg34 , arg35 , arg36 , arg37 , arg38 , arg39);
|
||||
}
|
||||
}}
|
||||
@@ -0,0 +1,34 @@
|
||||
# /* **************************************************************************
|
||||
# * *
|
||||
# * (C) Copyright Paul Mensonides 2002.
|
||||
# * 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 for most recent version. */
|
||||
#
|
||||
# ifndef BOOST_PREPROCESSOR_FACILITIES_APPLY_HPP
|
||||
# define BOOST_PREPROCESSOR_FACILITIES_APPLY_HPP
|
||||
#
|
||||
# include <boost/preprocessor/config/config.hpp>
|
||||
# include <boost/preprocessor/control/expr_iif.hpp>
|
||||
# include <boost/preprocessor/detail/is_unary.hpp>
|
||||
# include <boost/preprocessor/tuple/rem.hpp>
|
||||
#
|
||||
# /* BOOST_PP_APPLY */
|
||||
#
|
||||
# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG()
|
||||
# define BOOST_PP_APPLY(x) BOOST_PP_APPLY_I(x)
|
||||
# define BOOST_PP_APPLY_I(x) BOOST_PP_EXPR_IIF(BOOST_PP_IS_UNARY(x), BOOST_PP_TUPLE_REM_1 x)
|
||||
# elif BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_BCC()
|
||||
# define BOOST_PP_APPLY(x) BOOST_PP_APPLY_I(x)
|
||||
# define BOOST_PP_APPLY_I(x) BOOST_PP_APPLY_ ## x
|
||||
# define BOOST_PP_APPLY_(x) x
|
||||
# define BOOST_PP_APPLY_BOOST_PP_NIL
|
||||
# else
|
||||
# define BOOST_PP_APPLY(x) BOOST_PP_EXPR_IIF(BOOST_PP_IS_UNARY(x), BOOST_PP_TUPLE_REM_1 x)
|
||||
# endif
|
||||
#
|
||||
# endif
|
||||
@@ -0,0 +1,378 @@
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// (C) Copyright Ion Gaztanaga 2005-2013.
|
||||
//
|
||||
// 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/container for documentation.
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifndef BOOST_CONTAINER_DESTROYERS_HPP
|
||||
#define BOOST_CONTAINER_DESTROYERS_HPP
|
||||
|
||||
#ifndef BOOST_CONFIG_HPP
|
||||
# include <boost/config.hpp>
|
||||
#endif
|
||||
|
||||
#if defined(BOOST_HAS_PRAGMA_ONCE)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/container/detail/config_begin.hpp>
|
||||
#include <boost/container/detail/workaround.hpp>
|
||||
|
||||
#include <boost/container/allocator_traits.hpp>
|
||||
#include <boost/container/detail/to_raw_pointer.hpp>
|
||||
#include <boost/container/detail/version_type.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace container {
|
||||
namespace container_detail {
|
||||
|
||||
//!A deleter for scoped_ptr that deallocates the memory
|
||||
//!allocated for an object using a STL allocator.
|
||||
template <class Allocator>
|
||||
struct scoped_deallocator
|
||||
{
|
||||
typedef allocator_traits<Allocator> allocator_traits_type;
|
||||
typedef typename allocator_traits_type::pointer pointer;
|
||||
typedef container_detail::integral_constant<unsigned,
|
||||
boost::container::container_detail::
|
||||
version<Allocator>::value> alloc_version;
|
||||
|
||||
private:
|
||||
void priv_deallocate(version_1)
|
||||
{ m_alloc.deallocate(m_ptr, 1); }
|
||||
|
||||
void priv_deallocate(version_2)
|
||||
{ m_alloc.deallocate_one(m_ptr); }
|
||||
|
||||
BOOST_MOVABLE_BUT_NOT_COPYABLE(scoped_deallocator)
|
||||
|
||||
public:
|
||||
|
||||
pointer m_ptr;
|
||||
Allocator& m_alloc;
|
||||
|
||||
scoped_deallocator(pointer p, Allocator& a)
|
||||
: m_ptr(p), m_alloc(a)
|
||||
{}
|
||||
|
||||
~scoped_deallocator()
|
||||
{ if (m_ptr)priv_deallocate(alloc_version()); }
|
||||
|
||||
scoped_deallocator(BOOST_RV_REF(scoped_deallocator) o)
|
||||
: m_ptr(o.m_ptr), m_alloc(o.m_alloc)
|
||||
{ o.release(); }
|
||||
|
||||
pointer get() const
|
||||
{ return m_ptr; }
|
||||
|
||||
void set(const pointer &p)
|
||||
{ m_ptr = p; }
|
||||
|
||||
void release()
|
||||
{ m_ptr = 0; }
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
struct null_scoped_deallocator
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
|
||||
null_scoped_deallocator(pointer, Allocator&, size_type)
|
||||
{}
|
||||
|
||||
void release()
|
||||
{}
|
||||
|
||||
pointer get() const
|
||||
{ return pointer(); }
|
||||
|
||||
void set(const pointer &)
|
||||
{}
|
||||
};
|
||||
|
||||
//!A deleter for scoped_ptr that deallocates the memory
|
||||
//!allocated for an array of objects using a STL allocator.
|
||||
template <class Allocator>
|
||||
struct scoped_array_deallocator
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
|
||||
scoped_array_deallocator(pointer p, Allocator& a, size_type length)
|
||||
: m_ptr(p), m_alloc(a), m_length(length) {}
|
||||
|
||||
~scoped_array_deallocator()
|
||||
{ if (m_ptr) m_alloc.deallocate(m_ptr, m_length); }
|
||||
|
||||
void release()
|
||||
{ m_ptr = 0; }
|
||||
|
||||
private:
|
||||
pointer m_ptr;
|
||||
Allocator& m_alloc;
|
||||
size_type m_length;
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
struct null_scoped_array_deallocator
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
|
||||
null_scoped_array_deallocator(pointer, Allocator&, size_type)
|
||||
{}
|
||||
|
||||
void release()
|
||||
{}
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
struct scoped_destroy_deallocator
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
typedef container_detail::integral_constant<unsigned,
|
||||
boost::container::container_detail::
|
||||
version<Allocator>::value> alloc_version;
|
||||
|
||||
scoped_destroy_deallocator(pointer p, Allocator& a)
|
||||
: m_ptr(p), m_alloc(a) {}
|
||||
|
||||
~scoped_destroy_deallocator()
|
||||
{
|
||||
if(m_ptr){
|
||||
AllocTraits::destroy(m_alloc, container_detail::to_raw_pointer(m_ptr));
|
||||
priv_deallocate(m_ptr, alloc_version());
|
||||
}
|
||||
}
|
||||
|
||||
void release()
|
||||
{ m_ptr = 0; }
|
||||
|
||||
private:
|
||||
|
||||
void priv_deallocate(const pointer &p, version_1)
|
||||
{ AllocTraits::deallocate(m_alloc, p, 1); }
|
||||
|
||||
void priv_deallocate(const pointer &p, version_2)
|
||||
{ m_alloc.deallocate_one(p); }
|
||||
|
||||
pointer m_ptr;
|
||||
Allocator& m_alloc;
|
||||
};
|
||||
|
||||
|
||||
//!A deleter for scoped_ptr that destroys
|
||||
//!an object using a STL allocator.
|
||||
template <class Allocator>
|
||||
struct scoped_destructor_n
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::value_type value_type;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
|
||||
scoped_destructor_n(pointer p, Allocator& a, size_type n)
|
||||
: m_p(p), m_a(a), m_n(n)
|
||||
{}
|
||||
|
||||
void release()
|
||||
{ m_p = 0; }
|
||||
|
||||
void increment_size(size_type inc)
|
||||
{ m_n += inc; }
|
||||
|
||||
void increment_size_backwards(size_type inc)
|
||||
{ m_n += inc; m_p -= inc; }
|
||||
|
||||
void shrink_forward(size_type inc)
|
||||
{ m_n -= inc; m_p += inc; }
|
||||
|
||||
~scoped_destructor_n()
|
||||
{
|
||||
if(!m_p) return;
|
||||
value_type *raw_ptr = container_detail::to_raw_pointer(m_p);
|
||||
while(m_n--){
|
||||
AllocTraits::destroy(m_a, raw_ptr++);
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
pointer m_p;
|
||||
Allocator & m_a;
|
||||
size_type m_n;
|
||||
};
|
||||
|
||||
//!A deleter for scoped_ptr that destroys
|
||||
//!an object using a STL allocator.
|
||||
template <class Allocator>
|
||||
struct null_scoped_destructor_n
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef typename AllocTraits::size_type size_type;
|
||||
|
||||
null_scoped_destructor_n(pointer, Allocator&, size_type)
|
||||
{}
|
||||
|
||||
void increment_size(size_type)
|
||||
{}
|
||||
|
||||
void increment_size_backwards(size_type)
|
||||
{}
|
||||
|
||||
void shrink_forward(size_type)
|
||||
{}
|
||||
|
||||
void release()
|
||||
{}
|
||||
};
|
||||
|
||||
template<class Allocator>
|
||||
class scoped_destructor
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
public:
|
||||
typedef typename Allocator::value_type value_type;
|
||||
scoped_destructor(Allocator &a, value_type *pv)
|
||||
: pv_(pv), a_(a)
|
||||
{}
|
||||
|
||||
~scoped_destructor()
|
||||
{
|
||||
if(pv_){
|
||||
AllocTraits::destroy(a_, pv_);
|
||||
}
|
||||
}
|
||||
|
||||
void release()
|
||||
{ pv_ = 0; }
|
||||
|
||||
|
||||
void set(value_type *ptr) { pv_ = ptr; }
|
||||
|
||||
value_type *get() const { return pv_; }
|
||||
|
||||
private:
|
||||
value_type *pv_;
|
||||
Allocator &a_;
|
||||
};
|
||||
|
||||
|
||||
template<class Allocator>
|
||||
class value_destructor
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
public:
|
||||
typedef typename Allocator::value_type value_type;
|
||||
value_destructor(Allocator &a, value_type &rv)
|
||||
: rv_(rv), a_(a)
|
||||
{}
|
||||
|
||||
~value_destructor()
|
||||
{
|
||||
AllocTraits::destroy(a_, &rv_);
|
||||
}
|
||||
|
||||
private:
|
||||
value_type &rv_;
|
||||
Allocator &a_;
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
class allocator_destroyer
|
||||
{
|
||||
typedef boost::container::allocator_traits<Allocator> AllocTraits;
|
||||
typedef typename AllocTraits::value_type value_type;
|
||||
typedef typename AllocTraits::pointer pointer;
|
||||
typedef container_detail::integral_constant<unsigned,
|
||||
boost::container::container_detail::
|
||||
version<Allocator>::value> alloc_version;
|
||||
|
||||
private:
|
||||
Allocator & a_;
|
||||
|
||||
private:
|
||||
void priv_deallocate(const pointer &p, version_1)
|
||||
{ AllocTraits::deallocate(a_,p, 1); }
|
||||
|
||||
void priv_deallocate(const pointer &p, version_2)
|
||||
{ a_.deallocate_one(p); }
|
||||
|
||||
public:
|
||||
explicit allocator_destroyer(Allocator &a)
|
||||
: a_(a)
|
||||
{}
|
||||
|
||||
void operator()(const pointer &p)
|
||||
{
|
||||
AllocTraits::destroy(a_, container_detail::to_raw_pointer(p));
|
||||
this->priv_deallocate(p, alloc_version());
|
||||
}
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
class allocator_destroyer_and_chain_builder
|
||||
{
|
||||
typedef allocator_traits<Allocator> allocator_traits_type;
|
||||
typedef typename allocator_traits_type::value_type value_type;
|
||||
typedef typename Allocator::multiallocation_chain multiallocation_chain;
|
||||
|
||||
Allocator & a_;
|
||||
multiallocation_chain &c_;
|
||||
|
||||
public:
|
||||
allocator_destroyer_and_chain_builder(Allocator &a, multiallocation_chain &c)
|
||||
: a_(a), c_(c)
|
||||
{}
|
||||
|
||||
void operator()(const typename Allocator::pointer &p)
|
||||
{
|
||||
allocator_traits<Allocator>::destroy(a_, container_detail::to_raw_pointer(p));
|
||||
c_.push_back(p);
|
||||
}
|
||||
};
|
||||
|
||||
template <class Allocator>
|
||||
class allocator_multialloc_chain_node_deallocator
|
||||
{
|
||||
typedef allocator_traits<Allocator> allocator_traits_type;
|
||||
typedef typename allocator_traits_type::value_type value_type;
|
||||
typedef typename Allocator::multiallocation_chain multiallocation_chain;
|
||||
typedef allocator_destroyer_and_chain_builder<Allocator> chain_builder;
|
||||
|
||||
Allocator & a_;
|
||||
multiallocation_chain c_;
|
||||
|
||||
public:
|
||||
allocator_multialloc_chain_node_deallocator(Allocator &a)
|
||||
: a_(a), c_()
|
||||
{}
|
||||
|
||||
chain_builder get_chain_builder()
|
||||
{ return chain_builder(a_, c_); }
|
||||
|
||||
~allocator_multialloc_chain_node_deallocator()
|
||||
{
|
||||
a_.deallocate_individual(c_);
|
||||
}
|
||||
};
|
||||
|
||||
} //namespace container_detail {
|
||||
} //namespace container {
|
||||
} //namespace boost {
|
||||
|
||||
#include <boost/container/detail/config_end.hpp>
|
||||
|
||||
#endif //#ifndef BOOST_CONTAINER_DESTROYERS_HPP
|
||||
@@ -0,0 +1,46 @@
|
||||
/*=============================================================================
|
||||
Copyright (c) 2014 Kohei Takahashi
|
||||
|
||||
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 FUSION_MAKE_LIST_10262014_0647
|
||||
#define FUSION_MAKE_LIST_10262014_0647
|
||||
|
||||
#include <boost/fusion/support/config.hpp>
|
||||
#include <boost/fusion/container/list/list.hpp>
|
||||
|
||||
#if !defined(BOOST_FUSION_HAS_VARIADIC_LIST)
|
||||
# include <boost/fusion/container/generation/detail/pp_make_list.hpp>
|
||||
#else
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// C++11 variadic interface
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#include <boost/fusion/support/detail/as_fusion_element.hpp>
|
||||
|
||||
namespace boost { namespace fusion
|
||||
{
|
||||
namespace result_of
|
||||
{
|
||||
template <typename ...T>
|
||||
struct make_list
|
||||
{
|
||||
typedef list<typename detail::as_fusion_element<T>::type...> type;
|
||||
};
|
||||
}
|
||||
|
||||
template <typename ...T>
|
||||
BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
|
||||
inline typename result_of::make_list<T...>::type
|
||||
make_list(T const&... arg)
|
||||
{
|
||||
return typename result_of::make_list<T...>::type(arg...);
|
||||
}
|
||||
}}
|
||||
|
||||
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
/*
|
||||
[auto_generated]
|
||||
boost/numeric/odeint/integrate/integrate_const.hpp
|
||||
|
||||
[begin_description]
|
||||
Constant integration of ODEs, meaning that the state of the ODE is observed on constant time intervals.
|
||||
The routines makes full use of adaptive and dense-output methods.
|
||||
[end_description]
|
||||
|
||||
Copyright 2009-2011 Karsten Ahnert
|
||||
Copyright 2009-2011 Mario Mulansky
|
||||
|
||||
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_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
|
||||
#define BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
|
||||
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
|
||||
#include <boost/numeric/odeint/stepper/stepper_categories.hpp>
|
||||
#include <boost/numeric/odeint/iterator/integrate/null_observer.hpp>
|
||||
#include <boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp>
|
||||
#include <boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace numeric {
|
||||
namespace odeint {
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Integrates with constant time step dt.
|
||||
*/
|
||||
template< class Stepper , class System , class State , class Time , class Observer >
|
||||
size_t integrate_const(
|
||||
Stepper stepper , System system , State &start_state ,
|
||||
Time start_time , Time end_time , Time dt ,
|
||||
Observer observer
|
||||
)
|
||||
{
|
||||
typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
|
||||
// we want to get as fast as possible to the end
|
||||
if( boost::is_same< null_observer , Observer >::value )
|
||||
{
|
||||
return detail::integrate_adaptive(
|
||||
stepper , system , start_state ,
|
||||
start_time , end_time , dt ,
|
||||
observer , stepper_category() );
|
||||
}
|
||||
else
|
||||
{
|
||||
return detail::integrate_const( stepper , system , start_state ,
|
||||
start_time , end_time , dt ,
|
||||
observer , stepper_category() );
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Second version to solve the forwarding problem,
|
||||
* can be called with Boost.Range as start_state.
|
||||
*/
|
||||
template< class Stepper , class System , class State , class Time , class Observer >
|
||||
size_t integrate_const(
|
||||
Stepper stepper , System system , const State &start_state ,
|
||||
Time start_time , Time end_time , Time dt ,
|
||||
Observer observer
|
||||
)
|
||||
{
|
||||
typedef typename odeint::unwrap_reference< Stepper >::type::stepper_category stepper_category;
|
||||
// we want to get as fast as possible to the end
|
||||
if( boost::is_same< null_observer , Observer >::value )
|
||||
{
|
||||
return detail::integrate_adaptive(
|
||||
stepper , system , start_state ,
|
||||
start_time , end_time , dt ,
|
||||
observer , stepper_category() );
|
||||
}
|
||||
else
|
||||
{
|
||||
return detail::integrate_const( stepper , system , start_state ,
|
||||
start_time , end_time , dt ,
|
||||
observer , stepper_category() );
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* \brief integrate_const without observer calls
|
||||
*/
|
||||
template< class Stepper , class System , class State , class Time >
|
||||
size_t integrate_const(
|
||||
Stepper stepper , System system , State &start_state ,
|
||||
Time start_time , Time end_time , Time dt
|
||||
)
|
||||
{
|
||||
return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() );
|
||||
}
|
||||
|
||||
/**
|
||||
* \brief Second version to solve the forwarding problem,
|
||||
* can be called with Boost.Range as start_state.
|
||||
*/
|
||||
template< class Stepper , class System , class State , class Time >
|
||||
size_t integrate_const(
|
||||
Stepper stepper , System system , const State &start_state ,
|
||||
Time start_time , Time end_time , Time dt
|
||||
)
|
||||
{
|
||||
return integrate_const( stepper , system , start_state , start_time , end_time , dt , null_observer() );
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/********* DOXYGEN *********/
|
||||
/**
|
||||
* \fn integrate_const( Stepper stepper , System system , State &start_state , Time start_time , Time end_time , Time dt , Observer observer )
|
||||
* \brief Integrates the ODE with constant step size.
|
||||
*
|
||||
* Integrates the ODE defined by system using the given stepper.
|
||||
* This method ensures that the observer is called at constant intervals dt.
|
||||
* If the Stepper is a normal stepper without step size control, dt is also
|
||||
* used for the numerical scheme. If a ControlledStepper is provided, the
|
||||
* algorithm might reduce the step size to meet the error bounds, but it is
|
||||
* ensured that the observer is always called at equidistant time points
|
||||
* t0 + n*dt. If a DenseOutputStepper is used, the step size also may vary
|
||||
* and the dense output is used to call the observer at equidistant time
|
||||
* points.
|
||||
*
|
||||
* \param stepper The stepper to be used for numerical integration.
|
||||
* \param system Function/Functor defining the rhs of the ODE.
|
||||
* \param start_state The initial condition x0.
|
||||
* \param start_time The initial time t0.
|
||||
* \param end_time The final integration time tend.
|
||||
* \param dt The time step between observer calls, _not_ necessarily the
|
||||
* time step of the integration.
|
||||
* \param observer Function/Functor called at equidistant time intervals.
|
||||
* \return The number of steps performed.
|
||||
*/
|
||||
|
||||
} // namespace odeint
|
||||
} // namespace numeric
|
||||
} // namespace boost
|
||||
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_ODEINT_INTEGRATE_INTEGRATE_CONST_HPP_INCLUDED
|
||||
@@ -0,0 +1,102 @@
|
||||
|
||||
// Copyright Aleksey Gurtovoy 2000-2004
|
||||
//
|
||||
// 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)
|
||||
//
|
||||
|
||||
// Preprocessed version of "boost/mpl/equal_to.hpp" header
|
||||
// -- DO NOT modify by hand!
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<
|
||||
typename Tag1
|
||||
, typename Tag2
|
||||
|
||||
, BOOST_MPL_AUX_NTTP_DECL(int, tag1_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag1)::value
|
||||
, BOOST_MPL_AUX_NTTP_DECL(int, tag2_) = BOOST_MPL_AUX_MSVC_VALUE_WKND(Tag2)::value
|
||||
>
|
||||
struct equal_to_impl
|
||||
: if_c<
|
||||
( tag1_ > tag2_ )
|
||||
, aux::cast2nd_impl< equal_to_impl< Tag1,Tag1 >,Tag1, Tag2 >
|
||||
, aux::cast1st_impl< equal_to_impl< Tag2,Tag2 >,Tag1, Tag2 >
|
||||
>::type
|
||||
{
|
||||
};
|
||||
|
||||
/// for Digital Mars C++/compilers with no CTPS/TTP support
|
||||
template<> struct equal_to_impl< na,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct equal_to_impl< na,integral_c_tag >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template<> struct equal_to_impl< integral_c_tag,na >
|
||||
{
|
||||
template< typename U1, typename U2 > struct apply
|
||||
{
|
||||
typedef apply type;
|
||||
BOOST_STATIC_CONSTANT(int, value = 0);
|
||||
};
|
||||
};
|
||||
|
||||
template< typename T > struct equal_to_tag
|
||||
: tag< T,na >
|
||||
{
|
||||
};
|
||||
|
||||
template<
|
||||
typename BOOST_MPL_AUX_NA_PARAM(N1)
|
||||
, typename BOOST_MPL_AUX_NA_PARAM(N2)
|
||||
>
|
||||
struct equal_to
|
||||
: aux::msvc_eti_base< typename apply_wrap2<
|
||||
equal_to_impl<
|
||||
typename equal_to_tag<N1>::type
|
||||
, typename equal_to_tag<N2>::type
|
||||
>
|
||||
, N1
|
||||
, N2
|
||||
>::type >::type
|
||||
|
||||
{
|
||||
BOOST_MPL_AUX_LAMBDA_SUPPORT(2, equal_to, (N1, N2))
|
||||
|
||||
};
|
||||
|
||||
BOOST_MPL_AUX_NA_SPEC2(2, 2, equal_to)
|
||||
|
||||
}}
|
||||
|
||||
namespace boost { namespace mpl {
|
||||
|
||||
template<>
|
||||
struct equal_to_impl< integral_c_tag,integral_c_tag >
|
||||
{
|
||||
template< typename N1, typename N2 > struct apply
|
||||
|
||||
{
|
||||
BOOST_STATIC_CONSTANT(bool, value =
|
||||
( BOOST_MPL_AUX_VALUE_WKND(N1)::value ==
|
||||
BOOST_MPL_AUX_VALUE_WKND(N2)::value )
|
||||
);
|
||||
typedef bool_<value> type;
|
||||
};
|
||||
};
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,34 @@
|
||||
// Boost.Range library
|
||||
//
|
||||
// Copyright Thorsten Ottosen 2003-2006. Use, modification and
|
||||
// distribution is subject to 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)
|
||||
//
|
||||
// For more information, see http://www.boost.org/libs/range/
|
||||
//
|
||||
|
||||
#ifndef BOOST_RANGE_DISTANCE_HPP
|
||||
#define BOOST_RANGE_DISTANCE_HPP
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
# pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/range/begin.hpp>
|
||||
#include <boost/range/end.hpp>
|
||||
#include <boost/range/difference_type.hpp>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
|
||||
template< class T >
|
||||
inline BOOST_DEDUCED_TYPENAME range_difference<T>::type
|
||||
distance( const T& r )
|
||||
{
|
||||
return std::distance( boost::begin( r ), boost::end( r ) );
|
||||
}
|
||||
|
||||
} // namespace 'boost'
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,208 @@
|
||||
#include "adif.h"
|
||||
|
||||
#include <QFile>
|
||||
#include <QTextStream>
|
||||
#include <QDebug>
|
||||
|
||||
/*
|
||||
<CALL:4>W1XT<BAND:3>20m<FREQ:6>14.076<GRIDSQUARE:4>DM33<MODE:4>JT65<RST_RCVD:3>-21<RST_SENT:3>-14<QSO_DATE:8>20110422<TIME_ON:4>0417<TIME_OFF:4>0424<TX_PWR:1>4<COMMENT:34>1st JT65A QSO. Him: mag loop 20W<STATION_CALLSIGN:6>VK3ACF<MY_GRIDSQUARE:6>qf22lb<eor>
|
||||
<CALL:6>IK1SOW<BAND:3>20m<FREQ:6>14.076<GRIDSQUARE:4>JN35<MODE:4>JT65<RST_RCVD:3>-19<RST_SENT:3>-11<QSO_DATE:8>20110422<TIME_ON:4>0525<TIME_OFF:4>0533<TX_PWR:1>3<STATION_CALLSIGN:6>VK3ACF<MY_GRIDSQUARE:6>qf22lb<eor>
|
||||
<CALL:6:S>W4ABC> ...
|
||||
*/
|
||||
|
||||
void ADIF::init(QString filename)
|
||||
{
|
||||
_filename = filename;
|
||||
_data.clear();
|
||||
}
|
||||
|
||||
|
||||
QString ADIF::_extractField(const QString line, const QString fieldName)
|
||||
{
|
||||
int fieldNameIndex = line.indexOf(fieldName,0,Qt::CaseInsensitive);
|
||||
if (fieldNameIndex >=0)
|
||||
{
|
||||
int closingBracketIndex = line.indexOf('>',fieldNameIndex);
|
||||
int fieldLengthIndex = line.indexOf(':',fieldNameIndex); // find the size delimiter
|
||||
int dataTypeIndex = -1;
|
||||
if (fieldLengthIndex >= 0)
|
||||
{
|
||||
dataTypeIndex = line.indexOf(':',fieldLengthIndex+1); // check for a second : indicating there is a data type
|
||||
if (dataTypeIndex > closingBracketIndex)
|
||||
dataTypeIndex = -1; // second : was found but it was beyond the closing >
|
||||
}
|
||||
|
||||
if ((closingBracketIndex > fieldNameIndex) && (fieldLengthIndex > fieldNameIndex) && (fieldLengthIndex< closingBracketIndex))
|
||||
{
|
||||
int fieldLengthCharCount = closingBracketIndex - fieldLengthIndex -1;
|
||||
if (dataTypeIndex >= 0)
|
||||
fieldLengthCharCount -= 2; // data type indicator is always a colon followed by a single character
|
||||
QString fieldLengthString = line.mid(fieldLengthIndex+1,fieldLengthCharCount);
|
||||
int fieldLength = fieldLengthString.toInt();
|
||||
if (fieldLength > 0)
|
||||
{
|
||||
QString field = line.mid(closingBracketIndex+1,fieldLength);
|
||||
return field;
|
||||
}
|
||||
}
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
|
||||
|
||||
void ADIF::load()
|
||||
{
|
||||
_data.clear();
|
||||
QFile inputFile(_filename);
|
||||
if (inputFile.open(QIODevice::ReadOnly))
|
||||
{
|
||||
QTextStream in(&inputFile);
|
||||
while ( !in.atEnd() )
|
||||
{
|
||||
QString line = in.readLine();
|
||||
QSO q;
|
||||
q.call = _extractField(line,"CALL:");
|
||||
q.band = _extractField(line,"BAND:");
|
||||
q.mode = _extractField(line,"MODE:");
|
||||
q.date = _extractField(line,"QSO_DATE:");
|
||||
if (q.call != "")
|
||||
_data.insert(q.call,q);
|
||||
}
|
||||
inputFile.close();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void ADIF::add(const QString call, const QString band, const QString mode, const QString date)
|
||||
{
|
||||
QSO q;
|
||||
q.call = call;
|
||||
q.band = band;
|
||||
q.mode = mode;
|
||||
q.date = date;
|
||||
_data.insert(q.call,q);
|
||||
//qDebug() << "Added as worked:" << call << band << mode << date;
|
||||
}
|
||||
|
||||
// return true if in the log same band and mode (where JT65 == JT9)
|
||||
bool ADIF::match(const QString call, const QString band, const QString mode)
|
||||
{
|
||||
QList<QSO> qsos = _data.values(call);
|
||||
if (qsos.size()>0)
|
||||
{
|
||||
QSO q;
|
||||
foreach(q,qsos)
|
||||
{
|
||||
if ( (band.compare(q.band,Qt::CaseInsensitive) == 0)
|
||||
|| (band=="")
|
||||
|| (q.band==""))
|
||||
{
|
||||
if (
|
||||
(
|
||||
((mode.compare("JT65",Qt::CaseInsensitive)==0) || (mode.compare("JT9",Qt::CaseInsensitive)==0))
|
||||
&&
|
||||
((q.mode.compare("JT65",Qt::CaseInsensitive)==0) || (q.mode.compare("JT9",Qt::CaseInsensitive)==0))
|
||||
)
|
||||
|| (mode.compare(q.mode,Qt::CaseInsensitive)==0)
|
||||
|| (mode=="")
|
||||
|| (q.mode=="")
|
||||
)
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
QList<QString> ADIF::getCallList()
|
||||
{
|
||||
QList<QString> p;
|
||||
QMultiHash<QString,QSO>::const_iterator i = _data.constBegin();
|
||||
while (i != _data.constEnd())
|
||||
{
|
||||
p << i.key();
|
||||
++i;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
int ADIF::getCount()
|
||||
{
|
||||
return _data.size();
|
||||
}
|
||||
|
||||
|
||||
// open ADIF file and append the QSO details. Return true on success
|
||||
bool ADIF::addQSOToFile(const QString hisCall, const QString hisGrid, const QString mode, const QString rptSent, const QString rptRcvd, const QString dateOn, const QString timeOn, QString dateOff, const QString timeOff, const QString band,
|
||||
const QString comments, const QString name, const QString strDialFreq, const QString m_myCall, const QString m_myGrid, const QString m_txPower)
|
||||
{
|
||||
QFile f2(_filename);
|
||||
if (!f2.open(QIODevice::Text | QIODevice::Append))
|
||||
return false;
|
||||
else
|
||||
{
|
||||
QTextStream out(&f2);
|
||||
if (f2.size()==0)
|
||||
out << "WSJT-X ADIF Export<eoh>" << endl; // new file
|
||||
|
||||
QString t;
|
||||
t="<call:" + QString::number(hisCall.length()) + ">" + hisCall;
|
||||
t+=" <gridsquare:" + QString::number(hisGrid.length()) + ">" + hisGrid;
|
||||
t+=" <mode:" + QString::number(mode.length()) + ">" + mode;
|
||||
t+=" <rst_sent:" + QString::number(rptSent.length()) + ">" + rptSent;
|
||||
t+=" <rst_rcvd:" + QString::number(rptRcvd.length()) + ">" + rptRcvd;
|
||||
t+=" <qso_date:8>" + dateOn;
|
||||
t+=" <time_on:4>" + timeOn;
|
||||
t+=" <qso_date_off:8>" + dateOff;
|
||||
t+=" <time_off:4>" + timeOff;
|
||||
t+=" <band:" + QString::number(band.length()) + ">" + band;
|
||||
t+=" <freq:" + QString::number(strDialFreq.length()) + ">" + strDialFreq;
|
||||
t+=" <station_callsign:" + QString::number(m_myCall.length()) + ">" +
|
||||
m_myCall;
|
||||
t+=" <my_gridsquare:" + QString::number(m_myGrid.length()) + ">" +
|
||||
m_myGrid;
|
||||
if(m_txPower!="") t+= " <tx_pwr:" + QString::number(m_txPower.length()) +
|
||||
">" + m_txPower;
|
||||
if(comments!="") t+=" <comment:" + QString::number(comments.length()) +
|
||||
">" + comments;
|
||||
if(name!="") t+=" <name:" + QString::number(name.length()) +
|
||||
">" + name;
|
||||
t+=" <eor>";
|
||||
out << t << endl;
|
||||
f2.close();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
QString ADIF::bandFromFrequency(double dialFreq)
|
||||
{
|
||||
QString band="";
|
||||
if(dialFreq>0.135 and dialFreq<0.139) band="2200m";
|
||||
else if(dialFreq>0.45 and dialFreq<0.55) band="630m";
|
||||
else if(dialFreq>1.8 and dialFreq<2.0) band="160m";
|
||||
else if(dialFreq>3.5 and dialFreq<4.0) band="80m";
|
||||
else if(dialFreq>5.1 and dialFreq<5.45) band="60m";
|
||||
else if(dialFreq>7.0 and dialFreq<7.3) band="40m";
|
||||
else if(dialFreq>10.0 and dialFreq<10.15) band="30m";
|
||||
else if(dialFreq>14.0 and dialFreq<14.35) band="20m";
|
||||
else if(dialFreq>18.068 and dialFreq<18.168) band="17m";
|
||||
else if(dialFreq>21.0 and dialFreq<21.45) band="15m";
|
||||
else if(dialFreq>24.890 and dialFreq<24.990) band="12m";
|
||||
else if(dialFreq>28.0 and dialFreq<29.7) band="10m";
|
||||
else if(dialFreq>50.0 and dialFreq<54.0) band="6m";
|
||||
else if(dialFreq>70.0 and dialFreq<71.0) band="4m";
|
||||
else if(dialFreq>144.0 and dialFreq<148.0) band="2m";
|
||||
else if(dialFreq>222.0 and dialFreq<225.0) band="1.25m";
|
||||
else if(dialFreq>420.0 and dialFreq<450.0) band="70cm";
|
||||
else if(dialFreq>902.0 and dialFreq<928.0) band="33cm";
|
||||
else if(dialFreq>1240.0 and dialFreq<1300.0) band="23cm";
|
||||
else if(dialFreq>2300.0 and dialFreq<2450.0) band="13cm";
|
||||
else if(dialFreq>3300.0 and dialFreq<3500.0) band="9cm";
|
||||
else if(dialFreq>5650.0 and dialFreq<5925.0) band="6cm";
|
||||
else if(dialFreq>10000.0 and dialFreq<10500.0) band="3cm";
|
||||
else if(dialFreq>24000.0 and dialFreq<24250.0) band="1.25cm";
|
||||
else if(dialFreq>47000.0 and dialFreq<47200.0) band="6mm";
|
||||
else if(dialFreq>75500.0 and dialFreq<81000.0) band="4mm";
|
||||
return band;
|
||||
}
|
||||
@@ -0,0 +1,318 @@
|
||||
/**
|
||||
* -*- c++ -*-
|
||||
*
|
||||
* \file end.hpp
|
||||
*
|
||||
* \brief The \c end operation.
|
||||
*
|
||||
* Copyright (c) 2009, Marco Guazzone
|
||||
*
|
||||
* 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)
|
||||
*
|
||||
* \author Marco Guazzone, marco.guazzone@gmail.com
|
||||
*/
|
||||
|
||||
|
||||
#ifndef BOOST_NUMERIC_UBLAS_OPERATION_END_HPP
|
||||
#define BOOST_NUMERIC_UBLAS_OPERATION_END_HPP
|
||||
|
||||
|
||||
#include <boost/numeric/ublas/expression_types.hpp>
|
||||
#include <boost/numeric/ublas/fwd.hpp>
|
||||
#include <boost/numeric/ublas/traits/const_iterator_type.hpp>
|
||||
#include <boost/numeric/ublas/traits/iterator_type.hpp>
|
||||
|
||||
|
||||
namespace boost { namespace numeric { namespace ublas {
|
||||
|
||||
namespace detail {
|
||||
|
||||
/**
|
||||
* \brief Auxiliary class for implementing the \c end operation.
|
||||
* \tparam CategoryT The expression category type (e.g., vector_tag).
|
||||
* \tparam TagT The dimension type tag (e.g., tag::major).
|
||||
* \tparam OrientationT The orientation category type (e.g., row_major_tag).
|
||||
*/
|
||||
template <typename CategoryT, typename TagT=void, typename OrientationT=void>
|
||||
struct end_impl;
|
||||
|
||||
|
||||
/// \brief Specialization of \c end_impl for iterating vector expressions.
|
||||
template <>
|
||||
struct end_impl<vector_tag,void,void>
|
||||
{
|
||||
/**
|
||||
* \brief Return an iterator to the last element of the given vector
|
||||
* expression.
|
||||
* \tparam ExprT A model of VectorExpression type.
|
||||
* \param e A vector expression.
|
||||
* \return An iterator over the given vector expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::iterator apply(ExprT& e)
|
||||
{
|
||||
return e.end();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return a const iterator to the last element of the given vector
|
||||
* expression.
|
||||
* \tparam ExprT A model of VectorExpression type.
|
||||
* \param e A vector expression.
|
||||
* \return A const iterator to the first element of the given vector
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::const_iterator apply(ExprT const& e)
|
||||
{
|
||||
return e.end();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c end_impl for iterating matrix expressions with a
|
||||
/// row-major orientation over the major dimension.
|
||||
template <>
|
||||
struct end_impl<matrix_tag,tag::major,row_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Return an iterator to the last element of the given row-major
|
||||
* matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return An iterator over the major dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::iterator1 apply(ExprT& e)
|
||||
{
|
||||
return e.end1();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return a const iterator to the last element of the given row-major
|
||||
* matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return A const iterator over the major dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::const_iterator1 apply(ExprT const& e)
|
||||
{
|
||||
return e.end1();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c end_impl for iterating matrix expressions with a
|
||||
/// column-major orientation over the major dimension.
|
||||
template <>
|
||||
struct end_impl<matrix_tag,tag::major,column_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Return an iterator to the last element of the given column-major
|
||||
* matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return An iterator over the major dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::iterator2 apply(ExprT& e)
|
||||
{
|
||||
return e.end2();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return a const iterator to the last element of the given
|
||||
* column-major matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return A const iterator over the major dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::const_iterator2 apply(ExprT const& e)
|
||||
{
|
||||
return e.end2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c end_impl for iterating matrix expressions with a
|
||||
/// row-major orientation over the minor dimension.
|
||||
template <>
|
||||
struct end_impl<matrix_tag,tag::minor,row_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Return an iterator to the last element of the given row-major
|
||||
* matrix expression over the minor dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return An iterator over the minor dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::iterator2 apply(ExprT& e)
|
||||
{
|
||||
return e.end2();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return a const iterator to the last element of the given
|
||||
* row-minor matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return A const iterator over the minor dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::const_iterator2 apply(ExprT const& e)
|
||||
{
|
||||
return e.end2();
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
/// \brief Specialization of \c end_impl for iterating matrix expressions with a
|
||||
/// column-major orientation over the minor dimension.
|
||||
template <>
|
||||
struct end_impl<matrix_tag,tag::minor,column_major_tag>
|
||||
{
|
||||
/**
|
||||
* \brief Return an iterator to the last element of the given column-major
|
||||
* matrix expression over the minor dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return An iterator over the minor dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::iterator1 apply(ExprT& e)
|
||||
{
|
||||
return e.end1();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief Return a const iterator to the last element of the given
|
||||
* column-minor matrix expression over the major dimension.
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return A const iterator over the minor dimension of the given matrix
|
||||
* expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
static typename ExprT::const_iterator1 apply(ExprT const& e)
|
||||
{
|
||||
return e.end1();
|
||||
}
|
||||
};
|
||||
|
||||
} // Namespace detail
|
||||
|
||||
|
||||
/**
|
||||
* \brief An iterator to the last element of the given vector expression.
|
||||
* \tparam ExprT A model of VectorExpression type.
|
||||
* \param e A vector expression.
|
||||
* \return An iterator to the last element of the given vector expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename ExprT::iterator end(vector_expression<ExprT>& e)
|
||||
{
|
||||
return detail::end_impl<typename ExprT::type_category>::apply(e());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief A const iterator to the last element of the given vector expression.
|
||||
* \tparam ExprT A model of VectorExpression type.
|
||||
* \param e A vector expression.
|
||||
* \return A const iterator to the last element of the given vector expression.
|
||||
*/
|
||||
template <typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename ExprT::const_iterator end(vector_expression<ExprT> const& e)
|
||||
{
|
||||
return detail::end_impl<typename ExprT::type_category>::apply(e());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief An iterator to the last element of the given matrix expression
|
||||
* according to its orientation.
|
||||
* \tparam DimTagT A dimension tag type (e.g., tag::major).
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return An iterator to the last element of the given matrix expression
|
||||
* according to its orientation.
|
||||
*/
|
||||
template <typename TagT, typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename iterator_type<ExprT,TagT>::type end(matrix_expression<ExprT>& e)
|
||||
{
|
||||
return detail::end_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief A const iterator to the last element of the given matrix expression
|
||||
* according to its orientation.
|
||||
* \tparam TagT A dimension tag type (e.g., tag::major).
|
||||
* \tparam ExprT A model of MatrixExpression type.
|
||||
* \param e A matrix expression.
|
||||
* \return A const iterator to the last element of the given matrix expression
|
||||
* according to its orientation.
|
||||
*/
|
||||
template <typename TagT, typename ExprT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename const_iterator_type<ExprT,TagT>::type end(matrix_expression<ExprT> const& e)
|
||||
{
|
||||
return detail::end_impl<typename ExprT::type_category, TagT, typename ExprT::orientation_category>::apply(e());
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief An iterator to the last element over the dual dimension of the given
|
||||
* iterator.
|
||||
* \tparam IteratorT A model of Iterator type.
|
||||
* \param it An iterator.
|
||||
* \return An iterator to the last element over the dual dimension of the given
|
||||
* iterator.
|
||||
*/
|
||||
template <typename IteratorT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename IteratorT::dual_iterator_type end(IteratorT& it)
|
||||
{
|
||||
return it.end();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* \brief A const iterator to the last element over the dual dimension of the
|
||||
* given iterator.
|
||||
* \tparam IteratorT A model of Iterator type.
|
||||
* \param it An iterator.
|
||||
* \return A const iterator to the last element over the dual dimension of the
|
||||
* given iterator.
|
||||
*/
|
||||
template <typename IteratorT>
|
||||
BOOST_UBLAS_INLINE
|
||||
typename IteratorT::dual_iterator_type end(IteratorT const& it)
|
||||
{
|
||||
return it.end();
|
||||
}
|
||||
|
||||
}}} // Namespace boost::numeric::ublas
|
||||
|
||||
|
||||
#endif // BOOST_NUMERIC_UBLAS_OPERATION_END_HPP
|
||||
@@ -0,0 +1,118 @@
|
||||
program ft8sim
|
||||
|
||||
! Generate simulated data for a 15-second HF/6m mode using 8-FSK.
|
||||
! Output is saved to a *.wav file.
|
||||
|
||||
use wavhdr
|
||||
include 'ft8_params.f90' !Set various constants
|
||||
type(hdr) h !Header for .wav file
|
||||
character arg*12,fname*17,sorm*1
|
||||
character msg*22,msgsent*22
|
||||
complex c0(0:NMAX-1)
|
||||
complex c(0:NMAX-1)
|
||||
integer itone(NN)
|
||||
integer*1 msgbits(KK)
|
||||
integer*2 iwave(NMAX) !Generated full-length waveform
|
||||
|
||||
! Get command-line argument(s)
|
||||
nargs=iargc()
|
||||
if(nargs.ne.8) then
|
||||
print*,'Usage: ft8sim "message" sorm f0 DT fdop del nfiles snr'
|
||||
print*,'Example: ft8sim "K1ABC W9XYZ EN37" m 1500.0 0.0 0.1 1.0 10 -18'
|
||||
print*,'sorm: "s" for single signal at 1500 Hz, "m" for 25 signals'
|
||||
print*,'f0 is ignored when sorm = m'
|
||||
go to 999
|
||||
endif
|
||||
call getarg(1,msg) !Message to be transmitted
|
||||
call getarg(2,sorm) !s for single signal, m for multiple sigs
|
||||
if(sorm.eq."s") then
|
||||
print*,"Generating single signal at 1500 Hz."
|
||||
nsig=1
|
||||
elseif( sorm.eq."m") then
|
||||
print*,"Generating 25 signals per file."
|
||||
nsig=25
|
||||
else
|
||||
print*,"sorm parameter must be s (single) or m (multiple)."
|
||||
goto 999
|
||||
endif
|
||||
call getarg(3,arg)
|
||||
read(arg,*) f0 !Frequency (only used for single-signal)
|
||||
call getarg(4,arg)
|
||||
read(arg,*) xdt !Time offset from nominal (s)
|
||||
call getarg(5,arg)
|
||||
read(arg,*) fspread !Watterson frequency spread (Hz)
|
||||
call getarg(6,arg)
|
||||
read(arg,*) delay !Watterson delay (ms)
|
||||
call getarg(7,arg)
|
||||
read(arg,*) nfiles !Number of files
|
||||
call getarg(8,arg)
|
||||
read(arg,*) snrdb !SNR_2500
|
||||
|
||||
twopi=8.0*atan(1.0)
|
||||
fs=12000.0 !Sample rate (Hz)
|
||||
dt=1.0/fs !Sample interval (s)
|
||||
tt=NSPS*dt !Duration of symbols (s)
|
||||
baud=1.0/tt !Keying rate (baud)
|
||||
bw=8*baud !Occupied bandwidth (Hz)
|
||||
txt=NZ*dt !Transmission length (s)
|
||||
bandwidth_ratio=2500.0/(fs/2.0)
|
||||
sig=sqrt(2*bandwidth_ratio) * 10.0**(0.05*snrdb)
|
||||
if(snrdb.gt.90.0) sig=1.0
|
||||
txt=NN*NSPS/12000.0
|
||||
|
||||
call genft8(msg,msgsent,msgbits,itone) !Source-encode, then get itone()
|
||||
write(*,1000) f0,xdt,txt,snrdb,bw,msgsent
|
||||
1000 format('f0:',f9.3,' DT:',f6.2,' TxT:',f6.1,' SNR:',f6.1, &
|
||||
' BW:',f4.1,2x,a22)
|
||||
|
||||
write(*,'(28i1,1x,28i1)') msgbits(1:56)
|
||||
write(*,'(16i1)') msgbits(57:72)
|
||||
write(*,'(3i1)') msgbits(73:75)
|
||||
write(*,'(12i1)') msgbits(76:87)
|
||||
|
||||
! call sgran()
|
||||
do ifile=1,nfiles
|
||||
c=0.
|
||||
do isig=1,nsig
|
||||
c0=0.
|
||||
if(nsig.eq.25) then
|
||||
f0=(isig+2)*100.0
|
||||
endif
|
||||
k=-1 + nint((xdt+0.5+0.01*gran())/dt)
|
||||
! k=-1 + nint((xdt+0.5)/dt)
|
||||
phi=0.0
|
||||
do j=1,NN !Generate complex waveform
|
||||
dphi=twopi*(f0+itone(j)*baud)*dt
|
||||
do i=1,NSPS
|
||||
k=k+1
|
||||
phi=mod(phi+dphi,twopi)
|
||||
if(k.ge.0 .and. k.lt.NMAX) c0(k)=cmplx(cos(phi),sin(phi))
|
||||
enddo
|
||||
enddo
|
||||
if(fspread.ne.0.0 .or. delay.ne.0.0) call watterson(c0,NMAX,fs,delay,fspread)
|
||||
c=c+sig*c0
|
||||
enddo
|
||||
if(snrdb.lt.90) then
|
||||
do i=0,NMAX-1 !Add gaussian noise at specified SNR
|
||||
xnoise=gran()
|
||||
ynoise=gran()
|
||||
c(i)=c(i) + cmplx(xnoise,ynoise)
|
||||
enddo
|
||||
endif
|
||||
|
||||
fac=32767.0
|
||||
rms=100.0
|
||||
if(snrdb.ge.90.0) iwave(1:NMAX)=nint(fac*real(c))
|
||||
if(snrdb.lt.90.0) iwave(1:NMAX)=nint(rms*real(c))
|
||||
|
||||
h=default_header(12000,NMAX)
|
||||
write(fname,1102) ifile
|
||||
1102 format('000000_',i6.6,'.wav')
|
||||
open(10,file=fname,status='unknown',access='stream')
|
||||
write(10) h,iwave !Save to *.wav file
|
||||
close(10)
|
||||
write(*,1110) ifile,xdt,f0,snrdb,fname
|
||||
1110 format(i4,f7.2,f8.2,f7.1,2x,a17)
|
||||
enddo
|
||||
|
||||
999 end program ft8sim
|
||||
Reference in New Issue
Block a user