text:
//  This file was automatically generated on Thu Aug 13 16:32:12 2015
//  by libs/config/tools/generate.cpp
//  Copyright John Maddock 2002-4.
//  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/config for the most recent version.//
//  Revision $Id$
//

// Test file for config setup
// This file should compile, if it does not then
// one or more macros need to be defined.
// see boost_*.ipp for more details

// Do not edit this file, it was generated automatically by

#include <boost/config.hpp>
#include <iostream>
#include "test.hpp"

int error_count = 0;

#ifndef BOOST_NO_ADL_BARRIER
#include "boost_no_adl_barrier.ipp"
#else
namespace boost_no_adl_barrier = empty_boost;
#endif
#ifndef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
#include "boost_no_arg_dep_lookup.ipp"
#else
namespace boost_no_argument_dependent_lookup = empty_boost;
#endif
#ifndef BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS
#include "boost_no_array_type_spec.ipp"
#else
namespace boost_no_array_type_specializations = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_AUTO_DECLARATIONS
#include "boost_no_auto_declarations.ipp"
#else
namespace boost_no_cxx11_auto_declarations = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
#include "boost_no_auto_multidecl.ipp"
#else
namespace boost_no_cxx11_auto_multideclarations = empty_boost;
#endif
#ifndef BOOST_NO_AUTO_PTR
#include "boost_no_auto_ptr.ipp"
#else
namespace boost_no_auto_ptr = empty_boost;
#endif
#ifndef BOOST_BCB_PARTIAL_SPECIALIZATION_BUG
#include "boost_no_bcb_partial_spec.ipp"
#else
namespace boost_bcb_partial_specialization_bug = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_CHAR16_T
#include "boost_no_char16_t.ipp"
#else
namespace boost_no_cxx11_char16_t = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_CHAR32_T
#include "boost_no_char32_t.ipp"
#else
namespace boost_no_cxx11_char32_t = empty_boost;
#endif
#ifndef BOOST_NO_COMPLETE_VALUE_INITIALIZATION
#include "boost_no_com_value_init.ipp"
#else
namespace boost_no_complete_value_initialization = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_CONSTEXPR
#include "boost_no_constexpr.ipp"
#else
namespace boost_no_cxx11_constexpr = empty_boost;
#endif
#ifndef BOOST_NO_CTYPE_FUNCTIONS
#include "boost_no_ctype_functions.ipp"
#else
namespace boost_no_ctype_functions = empty_boost;
#endif
#ifndef BOOST_NO_CV_SPECIALIZATIONS
#include "boost_no_cv_spec.ipp"
#else
namespace boost_no_cv_specializations = empty_boost;
#endif
#ifndef BOOST_NO_CV_VOID_SPECIALIZATIONS
#include "boost_no_cv_void_spec.ipp"
#else
namespace boost_no_cv_void_specializations = empty_boost;
#endif
#ifndef BOOST_NO_CWCHAR
#include "boost_no_cwchar.ipp"
#else
namespace boost_no_cwchar = empty_boost;
#endif
#ifndef BOOST_NO_CWCTYPE
#include "boost_no_cwctype.ipp"
#else
namespace boost_no_cwctype = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_ADDRESSOF
#include "boost_no_cxx11_addressof.ipp"
#else
namespace boost_no_cxx11_addressof = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_ALIGNAS
#include "boost_no_cxx11_alignas.ipp"
#else
namespace boost_no_cxx11_alignas = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_ALLOCATOR
#include "boost_no_cxx11_allocator.ipp"
#else
namespace boost_no_cxx11_allocator = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_ATOMIC_SMART_PTR
#include "boost_no_cxx11_atomic_sp.ipp"
#else
namespace boost_no_cxx11_atomic_smart_ptr = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_FINAL
#include "boost_no_cxx11_final.ipp"
#else
namespace boost_no_cxx11_final = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_ARRAY
#include "boost_no_cxx11_hdr_array.ipp"
#else
namespace boost_no_cxx11_hdr_array = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_ATOMIC
#include "boost_no_cxx11_hdr_atomic.ipp"
#else
namespace boost_no_cxx11_hdr_atomic = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_CHRONO
#include "boost_no_cxx11_hdr_chrono.ipp"
#else
namespace boost_no_cxx11_hdr_chrono = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_CODECVT
#include "boost_no_cxx11_hdr_codecvt.ipp"
#else
namespace boost_no_cxx11_hdr_codecvt = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
#include "boost_no_cxx11_hdr_condition_variable.ipp"
#else
namespace boost_no_cxx11_hdr_condition_variable = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_FORWARD_LIST
#include "boost_no_cxx11_hdr_forward_list.ipp"
#else
namespace boost_no_cxx11_hdr_forward_list = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_FUTURE
#include "boost_no_cxx11_hdr_future.ipp"
#else
namespace boost_no_cxx11_hdr_future = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
#include "boost_no_cxx11_hdr_initializer_list.ipp"
#else
namespace boost_no_cxx11_hdr_initializer_list = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_MUTEX
#include "boost_no_cxx11_hdr_mutex.ipp"
#else
namespace boost_no_cxx11_hdr_mutex = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_RANDOM
#include "boost_no_cxx11_hdr_random.ipp"
#else
namespace boost_no_cxx11_hdr_random = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_RATIO
#include "boost_no_cxx11_hdr_ratio.ipp"
#else
namespace boost_no_cxx11_hdr_ratio = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_REGEX
#include "boost_no_cxx11_hdr_regex.ipp"
#else
namespace boost_no_cxx11_hdr_regex = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
#include "boost_no_cxx11_hdr_system_error.ipp"
#else
namespace boost_no_cxx11_hdr_system_error = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_THREAD
#include "boost_no_cxx11_hdr_thread.ipp"
#else
namespace boost_no_cxx11_hdr_thread = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_TUPLE
#include "boost_no_cxx11_hdr_tuple.ipp"
#else
namespace boost_no_cxx11_hdr_tuple = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
#include "boost_no_cxx11_hdr_type_traits.ipp"
#else
namespace boost_no_cxx11_hdr_type_traits = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_TYPEINDEX
#include "boost_no_cxx11_hdr_typeindex.ipp"
#else
namespace boost_no_cxx11_hdr_typeindex = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_MAP
#include "boost_no_cxx11_hdr_unordered_map.ipp"
#else
namespace boost_no_cxx11_hdr_unordered_map = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
#include "boost_no_cxx11_hdr_unordered_set.ipp"
#else
namespace boost_no_cxx11_hdr_unordered_set = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_INLINE_NAMESPACES
#include "boost_no_cxx11_inline_namespaces.ipp"
#else
namespace boost_no_cxx11_inline_namespaces = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
#include "boost_no_cxx11_non_pub_def_fun.ipp"
#else
namespace boost_no_cxx11_non_public_defaulted_functions = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_NUMERIC_LIMITS
#include "boost_no_cxx11_numeric_limits.ipp"
#else
namespace boost_no_cxx11_numeric_limits = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
#include "boost_no_cxx11_ref_qualifiers.ipp"
#else
namespace boost_no_cxx11_ref_qualifiers = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_SMART_PTR
#include "boost_no_cxx11_smart_ptr.ipp"
#else
namespace boost_no_cxx11_smart_ptr = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_STD_ALIGN
#include "boost_no_cxx11_std_align.ipp"
#else
namespace boost_no_cxx11_std_align = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_TRAILING_RESULT_TYPES
#include "boost_no_cxx11_trailing_result_types.ipp"
#else
namespace boost_no_cxx11_trailing_result_types = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_USER_DEFINED_LITERALS
#include "boost_no_cxx11_user_lit.ipp"
#else
namespace boost_no_cxx11_user_defined_literals = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_BINARY_LITERALS
#include "boost_no_cxx14_binary_literals.ipp"
#else
namespace boost_no_cxx14_binary_literals = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_CONSTEXPR
#include "boost_no_cxx14_constexpr.ipp"
#else
namespace boost_no_cxx14_constexpr = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_DECLTYPE_AUTO
#include "boost_no_cxx14_decltype_auto.ipp"
#else
namespace boost_no_cxx14_decltype_auto = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_DIGIT_SEPARATORS
#include "boost_no_cxx14_digit_separator.ipp"
#else
namespace boost_no_cxx14_digit_separators = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_GENERIC_LAMBDAS
#include "boost_no_cxx14_generic_lambda.ipp"
#else
namespace boost_no_cxx14_generic_lambdas = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX
#include "boost_no_cxx14_hdr_shared_mutex.ipp"
#else
namespace boost_no_cxx14_hdr_shared_mutex = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
#include "boost_no_cxx14_lambda_capture.ipp"
#else
namespace boost_no_cxx14_initialized_lambda_captures = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_AGGREGATE_NSDMI
#include "boost_no_cxx14_member_init.ipp"
#else
namespace boost_no_cxx14_aggregate_nsdmi = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
#include "boost_no_cxx14_return_type_ded.ipp"
#else
namespace boost_no_cxx14_return_type_deduction = empty_boost;
#endif
#ifndef BOOST_NO_CXX14_VARIABLE_TEMPLATES
#include "boost_no_cxx14_var_templ.ipp"
#else
namespace boost_no_cxx14_variable_templates = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
#include "boost_no_cxx_hdr_functional.ipp"
#else
namespace boost_no_cxx11_hdr_functional = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_DECLTYPE
#include "boost_no_decltype.ipp"
#else
namespace boost_no_cxx11_decltype = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_DECLTYPE_N3276
#include "boost_no_decltype_n3276.ipp"
#else
namespace boost_no_cxx11_decltype_n3276 = empty_boost;
#endif
#ifndef BOOST_DEDUCED_TYPENAME
#include "boost_no_ded_typename.ipp"
#else
namespace boost_deduced_typename = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
#include "boost_no_defaulted_functions.ipp"
#else
namespace boost_no_cxx11_defaulted_functions = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_DELETED_FUNCTIONS
#include "boost_no_deleted_functions.ipp"
#else
namespace boost_no_cxx11_deleted_functions = empty_boost;
#endif
#ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
#include "boost_no_dep_nested_class.ipp"
#else
namespace boost_no_dependent_nested_derivations = empty_boost;
#endif
#ifndef BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS
#include "boost_no_dep_val_param.ipp"
#else
namespace boost_no_dependent_types_in_template_value_parameters = empty_boost;
#endif
#ifndef BOOST_NO_EXCEPTION_STD_NAMESPACE
#include "boost_no_excep_std.ipp"
#else
namespace boost_no_exception_std_namespace = empty_boost;
#endif
#ifndef BOOST_NO_EXCEPTIONS
#include "boost_no_exceptions.ipp"
#else
namespace boost_no_exceptions = empty_boost;
#endif
#ifndef BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS
#include "boost_no_exp_func_tem_arg.ipp"
#else
namespace boost_no_explicit_function_template_arguments = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
#include "boost_no_explicit_cvt_ops.ipp"
#else
namespace boost_no_cxx11_explicit_conversion_operators = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_EXTERN_TEMPLATE
#include "boost_no_extern_template.ipp"
#else
namespace boost_no_cxx11_extern_template = empty_boost;
#endif
#ifndef BOOST_NO_FENV_H
#include "boost_no_fenv_h.ipp"
#else
namespace boost_no_fenv_h = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
#include "boost_no_fixed_len_variadic_templates.ipp"
#else
namespace boost_no_cxx11_fixed_length_variadic_template_expansion_packs = empty_boost;
#endif
#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
#include "boost_no_func_tmp_order.ipp"
#else
namespace boost_no_function_template_ordering = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
#include "boost_no_function_template_default_args.ipp"
#else
namespace boost_no_cxx11_function_template_default_args = empty_boost;
#endif
#ifndef BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS
#include "boost_no_function_type_spec.ipp"
#else
namespace boost_no_function_type_specializations = empty_boost;
#endif
#ifndef BOOST_NO_MS_INT64_NUMERIC_LIMITS
#include "boost_no_i64_limits.ipp"
#else
namespace boost_no_ms_int64_numeric_limits = empty_boost;
#endif
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
#include "boost_no_inline_memb_init.ipp"
#else
namespace boost_no_inclass_member_initialization = empty_boost;
#endif
#ifndef BOOST_NO_INTEGRAL_INT64_T
#include "boost_no_integral_int64_t.ipp"
#else
namespace boost_no_integral_int64_t = empty_boost;
#endif
#ifndef BOOST_NO_IOSFWD
#include "boost_no_iosfwd.ipp"
#else
namespace boost_no_iosfwd = empty_boost;
#endif
#ifndef BOOST_NO_IOSTREAM
#include "boost_no_iostream.ipp"
#else
namespace boost_no_iostream = empty_boost;
#endif
#ifndef BOOST_NO_IS_ABSTRACT
#include "boost_no_is_abstract.ipp"
#else
namespace boost_no_is_abstract = empty_boost;
#endif
#ifndef BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS
#include "boost_no_iter_construct.ipp"
#else
namespace boost_no_templated_iterator_constructors = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_LAMBDAS
#include "boost_no_lambdas.ipp"
#else
namespace boost_no_cxx11_lambdas = empty_boost;
#endif
#ifndef BOOST_NO_LIMITS
#include "boost_no_limits.ipp"
#else
namespace boost_no_limits = empty_boost;
#endif
#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
#include "boost_no_limits_const_exp.ipp"
#else
namespace boost_no_limits_compile_time_constants = empty_boost;
#endif
#ifndef BOOST_NO_LONG_LONG_NUMERIC_LIMITS
#include "boost_no_ll_limits.ipp"
#else
namespace boost_no_long_long_numeric_limits = empty_boost;
#endif
#ifndef BOOST_NO_LONG_LONG
#include "boost_no_long_long.ipp"
#else
namespace boost_no_long_long = empty_boost;
#endif
#ifndef BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS
#include "boost_no_mem_func_spec.ipp"
#else
namespace boost_no_member_function_specializations = empty_boost;
#endif
#ifndef BOOST_NO_MEMBER_TEMPLATE_KEYWORD
#include "boost_no_mem_tem_keyword.ipp"
#else
namespace boost_no_member_template_keyword = empty_boost;
#endif
#ifndef BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS
#include "boost_no_mem_tem_pnts.ipp"
#else
namespace boost_no_pointer_to_member_template_parameters = empty_boost;
#endif
#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
#include "boost_no_mem_templ_frnds.ipp"
#else
namespace boost_no_member_template_friends = empty_boost;
#endif
#ifndef BOOST_NO_MEMBER_TEMPLATES
#include "boost_no_mem_templates.ipp"
#else
namespace boost_no_member_templates = empty_boost;
#endif
#ifndef BOOST_NO_NESTED_FRIENDSHIP
#include "boost_no_nested_friendship.ipp"
#else
namespace boost_no_nested_friendship = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_NOEXCEPT
#include "boost_no_noexcept.ipp"
#else
namespace boost_no_cxx11_noexcept = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_NULLPTR
#include "boost_no_nullptr.ipp"
#else
namespace boost_no_cxx11_nullptr = empty_boost;
#endif
#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
#include "boost_no_ops_in_namespace.ipp"
#else
namespace boost_no_operators_in_namespace = empty_boost;
#endif
#ifndef BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS
#include "boost_no_part_spec_def_args.ipp"
#else
namespace boost_no_partial_specialization_implicit_default_args = empty_boost;
#endif
#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
#include "boost_no_partial_spec.ipp"
#else
namespace boost_no_template_partial_specialization = empty_boost;
#endif
#ifndef BOOST_NO_PRIVATE_IN_AGGREGATE
#include "boost_no_priv_aggregate.ipp"
#else
namespace boost_no_private_in_aggregate = empty_boost;
#endif
#ifndef BOOST_NO_POINTER_TO_MEMBER_CONST
#include "boost_no_ptr_mem_const.ipp"
#else
namespace boost_no_pointer_to_member_const = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_RANGE_BASED_FOR
#include "boost_no_range_based_for.ipp"
#else
namespace boost_no_cxx11_range_based_for = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_RAW_LITERALS
#include "boost_no_raw_literals.ipp"
#else
namespace boost_no_cxx11_raw_literals = empty_boost;
#endif
#ifndef BOOST_NO_UNREACHABLE_RETURN_DETECTION
#include "boost_no_ret_det.ipp"
#else
namespace boost_no_unreachable_return_detection = empty_boost;
#endif
#ifndef BOOST_NO_RTTI
#include "boost_no_rtti.ipp"
#else
namespace boost_no_rtti = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
#include "boost_no_rvalue_references.ipp"
#else
namespace boost_no_cxx11_rvalue_references = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_SCOPED_ENUMS
#include "boost_no_scoped_enums.ipp"
#else
namespace boost_no_cxx11_scoped_enums = empty_boost;
#endif
#ifndef BOOST_NO_SFINAE
#include "boost_no_sfinae.ipp"
#else
namespace boost_no_sfinae = empty_boost;
#endif
#ifndef BOOST_NO_SFINAE_EXPR
#include "boost_no_sfinae_expr.ipp"
#else
namespace boost_no_sfinae_expr = empty_boost;
#endif
#ifndef BOOST_NO_STRINGSTREAM
#include "boost_no_sstream.ipp"
#else
namespace boost_no_stringstream = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_STATIC_ASSERT
#include "boost_no_static_assert.ipp"
#else
namespace boost_no_cxx11_static_assert = empty_boost;
#endif
#ifndef BOOST_NO_STD_ALLOCATOR
#include "boost_no_std_allocator.ipp"
#else
namespace boost_no_std_allocator = empty_boost;
#endif
#ifndef BOOST_NO_STD_DISTANCE
#include "boost_no_std_distance.ipp"
#else
namespace boost_no_std_distance = empty_boost;
#endif
#ifndef BOOST_NO_STD_ITERATOR_TRAITS
#include "boost_no_std_iter_traits.ipp"
#else
namespace boost_no_std_iterator_traits = empty_boost;
#endif
#ifndef BOOST_NO_STD_ITERATOR
#include "boost_no_std_iterator.ipp"
#else
namespace boost_no_std_iterator = empty_boost;
#endif
#ifndef BOOST_NO_STD_LOCALE
#include "boost_no_std_locale.ipp"
#else
namespace boost_no_std_locale = empty_boost;
#endif
#ifndef BOOST_NO_STD_MESSAGES
#include "boost_no_std_messages.ipp"
#else
namespace boost_no_std_messages = empty_boost;
#endif
#ifndef BOOST_NO_STD_MIN_MAX
#include "boost_no_std_min_max.ipp"
#else
namespace boost_no_std_min_max = empty_boost;
#endif
#ifndef BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN
#include "boost_no_std_oi_assign.ipp"
#else
namespace boost_no_std_output_iterator_assign = empty_boost;
#endif
#ifndef BOOST_NO_STD_TYPEINFO
#include "boost_no_std_typeinfo.ipp"
#else
namespace boost_no_std_typeinfo = empty_boost;
#endif
#ifndef BOOST_NO_STD_USE_FACET
#include "boost_no_std_use_facet.ipp"
#else
namespace boost_no_std_use_facet = empty_boost;
#endif
#ifndef BOOST_NO_STD_WSTREAMBUF
#include "boost_no_std_wstreambuf.ipp"
#else
namespace boost_no_std_wstreambuf = empty_boost;
#endif
#ifndef BOOST_NO_STD_WSTRING
#include "boost_no_std_wstring.ipp"
#else
namespace boost_no_std_wstring = empty_boost;
#endif
#ifndef BOOST_NO_STDC_NAMESPACE
#include "boost_no_stdc_namespace.ipp"
#else
namespace boost_no_stdc_namespace = empty_boost;
#endif
#ifndef BOOST_NO_SWPRINTF
#include "boost_no_swprintf.ipp"
#else
namespace boost_no_swprintf = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
#include "boost_no_tem_local_classes.ipp"
#else
namespace boost_no_cxx11_local_class_template_parameters = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_TEMPLATE_ALIASES
#include "boost_no_template_aliases.ipp"
#else
namespace boost_no_cxx11_template_aliases = empty_boost;
#endif
#ifndef BOOST_NO_TEMPLATED_IOSTREAMS
#include "boost_no_template_streams.ipp"
#else
namespace boost_no_templated_iostreams = empty_boost;
#endif
#ifndef BOOST_NO_TEMPLATE_TEMPLATES
#include "boost_no_template_template.ipp"
#else
namespace boost_no_template_templates = empty_boost;
#endif
#ifndef BOOST_NO_TWO_PHASE_NAME_LOOKUP
#include "boost_no_two_phase_lookup.ipp"
#else
namespace boost_no_two_phase_name_lookup = empty_boost;
#endif
#ifndef BOOST_NO_TYPEID
#include "boost_no_typeid.ipp"
#else
namespace boost_no_typeid = empty_boost;
#endif
#ifndef BOOST_NO_TYPENAME_WITH_CTOR
#include "boost_no_typename_with_ctor.ipp"
#else
namespace boost_no_typename_with_ctor = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_UNICODE_LITERALS
#include "boost_no_unicode_literals.ipp"
#else
namespace boost_no_cxx11_unicode_literals = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
#include "boost_no_unified_init.ipp"
#else
namespace boost_no_cxx11_unified_initialization_syntax = empty_boost;
#endif
#ifndef BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL
#include "boost_no_using_breaks_adl.ipp"
#else
namespace boost_function_scope_using_declaration_breaks_adl = empty_boost;
#endif
#ifndef BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
#include "boost_no_using_decl_overld.ipp"
#else
namespace boost_no_using_declaration_overloads_from_typename_base = empty_boost;
#endif
#ifndef BOOST_NO_USING_TEMPLATE
#include "boost_no_using_template.ipp"
#else
namespace boost_no_using_template = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_VARIADIC_MACROS
#include "boost_no_variadic_macros.ipp"
#else
namespace boost_no_cxx11_variadic_macros = empty_boost;
#endif
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#include "boost_no_variadic_templates.ipp"
#else
namespace boost_no_cxx11_variadic_templates = empty_boost;
#endif
#ifndef BOOST_NO_VOID_RETURNS
#include "boost_no_void_returns.ipp"
#else
namespace boost_no_void_returns = empty_boost;
#endif
#ifndef BOOST_NO_INTRINSIC_WCHAR_T
#include "boost_no_wchar_t.ipp"
#else
namespace boost_no_intrinsic_wchar_t = empty_boost;
#endif

#ifdef BOOST_HAS_TWO_ARG_USE_FACET
#include "boost_has_2arg_use_facet.ipp"
#else
namespace boost_has_two_arg_use_facet = empty_boost;
#endif
#ifdef BOOST_HAS_BETHREADS
#include "boost_has_bethreads.ipp"
#else
namespace boost_has_bethreads = empty_boost;
#endif
#ifdef BOOST_HAS_CLOCK_GETTIME
#include "boost_has_clock_gettime.ipp"
#else
namespace boost_has_clock_gettime = empty_boost;
#endif
#ifdef BOOST_HAS_DIRENT_H
#include "boost_has_dirent_h.ipp"
#else
namespace boost_has_dirent_h = empty_boost;
#endif
#ifdef BOOST_HAS_EXPM1
#include "boost_has_expm1.ipp"
#else
namespace boost_has_expm1 = empty_boost;
#endif
#ifdef BOOST_HAS_FLOAT128
#include "boost_has_float128.ipp"
#else
namespace boost_has_float128 = empty_boost;
#endif
#ifdef BOOST_HAS_FTIME
#include "boost_has_ftime.ipp"
#else
namespace boost_has_ftime = empty_boost;
#endif
#ifdef BOOST_HAS_GETSYSTEMTIMEASFILETIME
#include "boost_has_getsystemtimeasfiletime.ipp"
#else
namespace boost_has_getsystemtimeasfiletime = empty_boost;
#endif
#ifdef BOOST_HAS_GETTIMEOFDAY
#include "boost_has_gettimeofday.ipp"
#else
namespace boost_has_gettimeofday = empty_boost;
#endif
#ifdef BOOST_HAS_HASH
#include "boost_has_hash.ipp"
#else
namespace boost_has_hash = empty_boost;
#endif
#ifdef BOOST_HAS_INT128
#include "boost_has_int128.ipp"
#else
namespace boost_has_int128 = empty_boost;
#endif
#ifdef BOOST_HAS_LOG1P
#include "boost_has_log1p.ipp"
#else
namespace boost_has_log1p = empty_boost;
#endif
#ifdef BOOST_HAS_LONG_LONG
#include "boost_has_long_long.ipp"
#else
namespace boost_has_long_long = empty_boost;
#endif
#ifdef BOOST_HAS_MACRO_USE_FACET
#include "boost_has_macro_use_facet.ipp"
#else
namespace boost_has_macro_use_facet = empty_boost;
#endif
#ifdef BOOST_HAS_MS_INT64
#include "boost_has_ms_int64.ipp"
#else
namespace boost_has_ms_int64 = empty_boost;
#endif
#ifdef BOOST_HAS_NANOSLEEP
#include "boost_has_nanosleep.ipp"
#else
namespace boost_has_nanosleep = empty_boost;
#endif
#ifdef BOOST_HAS_NL_TYPES_H
#include "boost_has_nl_types_h.ipp"
#else
namespace boost_has_nl_types_h = empty_boost;
#endif
#ifdef BOOST_HAS_NRVO
#include "boost_has_nrvo.ipp"
#else
namespace boost_has_nrvo = empty_boost;
#endif
#ifdef BOOST_HAS_PARTIAL_STD_ALLOCATOR
#include "boost_has_part_alloc.ipp"
#else
namespace boost_has_partial_std_allocator = empty_boost;
#endif
#ifdef BOOST_HAS_PTHREAD_DELAY_NP
#include "boost_has_pthread_delay_np.ipp"
#else
namespace boost_has_pthread_delay_np = empty_boost;
#endif
#ifdef BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
#include "boost_has_pthread_ma_st.ipp"
#else
namespace boost_has_pthread_mutexattr_settype = empty_boost;
#endif
#ifdef BOOST_HAS_PTHREAD_YIELD
#include "boost_has_pthread_yield.ipp"
#else
namespace boost_has_pthread_yield = empty_boost;
#endif
#ifdef BOOST_HAS_PTHREADS
#include "boost_has_pthreads.ipp"
#else
namespace boost_has_pthreads = empty_boost;
#endif
#ifdef BOOST_HAS_RVALUE_REFS
#include "boost_has_rvalue_refs.ipp"
#else
namespace boost_has_rvalue_refs = empty_boost;
#endif
#ifdef BOOST_HAS_SCHED_YIELD
#include "boost_has_sched_yield.ipp"
#else
namespace boost_has_sched_yield = empty_boost;
#endif
#ifdef BOOST_HAS_SGI_TYPE_TRAITS
#include "boost_has_sgi_type_traits.ipp"
#else
namespace boost_has_sgi_type_traits = empty_boost;
#endif
#ifdef BOOST_HAS_SIGACTION
#include "boost_has_sigaction.ipp"
#else
namespace boost_has_sigaction = empty_boost;
#endif
#ifdef BOOST_HAS_SLIST
#include "boost_has_slist.ipp"
#else
namespace boost_has_slist = empty_boost;
#endif
#ifdef BOOST_HAS_STATIC_ASSERT
#include "boost_has_static_assert.ipp"
#else
namespace boost_has_static_assert = empty_boost;
#endif
#ifdef BOOST_HAS_STDINT_H
#include "boost_has_stdint_h.ipp"
#else
namespace boost_has_stdint_h = empty_boost;
#endif
#ifdef BOOST_HAS_STLP_USE_FACET
#include "boost_has_stlp_use_facet.ipp"
#else
namespace boost_has_stlp_use_facet = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_ARRAY
#include "boost_has_tr1_array.ipp"
#else
namespace boost_has_tr1_array = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_BIND
#include "boost_has_tr1_bind.ipp"
#else
namespace boost_has_tr1_bind = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_COMPLEX_OVERLOADS
#include "boost_has_tr1_complex_over.ipp"
#else
namespace boost_has_tr1_complex_overloads = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG
#include "boost_has_tr1_complex_trig.ipp"
#else
namespace boost_has_tr1_complex_inverse_trig = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_FUNCTION
#include "boost_has_tr1_function.ipp"
#else
namespace boost_has_tr1_function = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_HASH
#include "boost_has_tr1_hash.ipp"
#else
namespace boost_has_tr1_hash = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_MEM_FN
#include "boost_has_tr1_mem_fn.ipp"
#else
namespace boost_has_tr1_mem_fn = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_RANDOM
#include "boost_has_tr1_random.ipp"
#else
namespace boost_has_tr1_random = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_REFERENCE_WRAPPER
#include "boost_has_tr1_ref_wrap.ipp"
#else
namespace boost_has_tr1_reference_wrapper = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_REGEX
#include "boost_has_tr1_regex.ipp"
#else
namespace boost_has_tr1_regex = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_RESULT_OF
#include "boost_has_tr1_result_of.ipp"
#else
namespace boost_has_tr1_result_of = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_SHARED_PTR
#include "boost_has_tr1_shared_ptr.ipp"
#else
namespace boost_has_tr1_shared_ptr = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_TUPLE
#include "boost_has_tr1_tuple.ipp"
#else
namespace boost_has_tr1_tuple = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_TYPE_TRAITS
#include "boost_has_tr1_type_traits.ipp"
#else
namespace boost_has_tr1_type_traits = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_UNORDERED_MAP
#include "boost_has_tr1_unordered_map.ipp"
#else
namespace boost_has_tr1_unordered_map = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_UNORDERED_SET
#include "boost_has_tr1_unordered_set.ipp"
#else
namespace boost_has_tr1_unordered_set = empty_boost;
#endif
#ifdef BOOST_HAS_TR1_UTILITY
#include "boost_has_tr1_utility.ipp"
#else
namespace boost_has_tr1_utility = empty_boost;
#endif
#ifdef BOOST_HAS_UNISTD_H
#include "boost_has_unistd_h.ipp"
#else
namespace boost_has_unistd_h = empty_boost;
#endif
#ifdef BOOST_HAS_VARIADIC_TMPL
#include "boost_has_variadic_tmpl.ipp"
#else
namespace boost_has_variadic_tmpl = empty_boost;
#endif
#ifdef BOOST_MSVC6_MEMBER_TEMPLATES
#include "boost_has_vc6_mem_templ.ipp"
#else
namespace boost_msvc6_member_templates = empty_boost;
#endif
#ifdef BOOST_MSVC_STD_ITERATOR
#include "boost_has_vc_iterator.ipp"
#else
namespace boost_msvc_std_iterator = empty_boost;
#endif
#ifdef BOOST_HAS_WINTHREADS
#include "boost_has_winthreads.ipp"
#else
namespace boost_has_winthreads = empty_boost;
#endif

int main( int, char *[] )
{
   if(0 != boost_has_two_arg_use_facet::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TWO_ARG_USE_FACET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_bethreads::test())
   {
      std::cerr << "Failed test for BOOST_HAS_BETHREADS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_clock_gettime::test())
   {
      std::cerr << "Failed test for BOOST_HAS_CLOCK_GETTIME at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_dirent_h::test())
   {
      std::cerr << "Failed test for BOOST_HAS_DIRENT_H at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_expm1::test())
   {
      std::cerr << "Failed test for BOOST_HAS_EXPM1 at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_float128::test())
   {
      std::cerr << "Failed test for BOOST_HAS_FLOAT128 at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_ftime::test())
   {
      std::cerr << "Failed test for BOOST_HAS_FTIME at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_getsystemtimeasfiletime::test())
   {
      std::cerr << "Failed test for BOOST_HAS_GETSYSTEMTIMEASFILETIME at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_gettimeofday::test())
   {
      std::cerr << "Failed test for BOOST_HAS_GETTIMEOFDAY at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_hash::test())
   {
      std::cerr << "Failed test for BOOST_HAS_HASH at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_int128::test())
   {
      std::cerr << "Failed test for BOOST_HAS_INT128 at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_log1p::test())
   {
      std::cerr << "Failed test for BOOST_HAS_LOG1P at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_long_long::test())
   {
      std::cerr << "Failed test for BOOST_HAS_LONG_LONG at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_macro_use_facet::test())
   {
      std::cerr << "Failed test for BOOST_HAS_MACRO_USE_FACET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_ms_int64::test())
   {
      std::cerr << "Failed test for BOOST_HAS_MS_INT64 at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_nanosleep::test())
   {
      std::cerr << "Failed test for BOOST_HAS_NANOSLEEP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_nl_types_h::test())
   {
      std::cerr << "Failed test for BOOST_HAS_NL_TYPES_H at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_nrvo::test())
   {
      std::cerr << "Failed test for BOOST_HAS_NRVO at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_partial_std_allocator::test())
   {
      std::cerr << "Failed test for BOOST_HAS_PARTIAL_STD_ALLOCATOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_pthread_delay_np::test())
   {
      std::cerr << "Failed test for BOOST_HAS_PTHREAD_DELAY_NP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_pthread_mutexattr_settype::test())
   {
      std::cerr << "Failed test for BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_pthread_yield::test())
   {
      std::cerr << "Failed test for BOOST_HAS_PTHREAD_YIELD at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_pthreads::test())
   {
      std::cerr << "Failed test for BOOST_HAS_PTHREADS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_rvalue_refs::test())
   {
      std::cerr << "Failed test for BOOST_HAS_RVALUE_REFS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_sched_yield::test())
   {
      std::cerr << "Failed test for BOOST_HAS_SCHED_YIELD at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_sgi_type_traits::test())
   {
      std::cerr << "Failed test for BOOST_HAS_SGI_TYPE_TRAITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_sigaction::test())
   {
      std::cerr << "Failed test for BOOST_HAS_SIGACTION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_slist::test())
   {
      std::cerr << "Failed test for BOOST_HAS_SLIST at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_static_assert::test())
   {
      std::cerr << "Failed test for BOOST_HAS_STATIC_ASSERT at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_stdint_h::test())
   {
      std::cerr << "Failed test for BOOST_HAS_STDINT_H at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_stlp_use_facet::test())
   {
      std::cerr << "Failed test for BOOST_HAS_STLP_USE_FACET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_array::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_ARRAY at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_bind::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_BIND at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_complex_overloads::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_COMPLEX_OVERLOADS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_complex_inverse_trig::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_COMPLEX_INVERSE_TRIG at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_function::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_FUNCTION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_hash::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_HASH at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_mem_fn::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_MEM_FN at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_random::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_RANDOM at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_reference_wrapper::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_REFERENCE_WRAPPER at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_regex::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_REGEX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_result_of::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_RESULT_OF at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_shared_ptr::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_SHARED_PTR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_tuple::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_TUPLE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_type_traits::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_TYPE_TRAITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_unordered_map::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_UNORDERED_MAP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_unordered_set::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_UNORDERED_SET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_tr1_utility::test())
   {
      std::cerr << "Failed test for BOOST_HAS_TR1_UTILITY at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_unistd_h::test())
   {
      std::cerr << "Failed test for BOOST_HAS_UNISTD_H at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_variadic_tmpl::test())
   {
      std::cerr << "Failed test for BOOST_HAS_VARIADIC_TMPL at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_msvc6_member_templates::test())
   {
      std::cerr << "Failed test for BOOST_MSVC6_MEMBER_TEMPLATES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_msvc_std_iterator::test())
   {
      std::cerr << "Failed test for BOOST_MSVC_STD_ITERATOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_has_winthreads::test())
   {
      std::cerr << "Failed test for BOOST_HAS_WINTHREADS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_adl_barrier::test())
   {
      std::cerr << "Failed test for BOOST_NO_ADL_BARRIER at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_argument_dependent_lookup::test())
   {
      std::cerr << "Failed test for BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_array_type_specializations::test())
   {
      std::cerr << "Failed test for BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_auto_declarations::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_AUTO_DECLARATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_auto_multideclarations::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_auto_ptr::test())
   {
      std::cerr << "Failed test for BOOST_NO_AUTO_PTR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_bcb_partial_specialization_bug::test())
   {
      std::cerr << "Failed test for BOOST_BCB_PARTIAL_SPECIALIZATION_BUG at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_char16_t::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_CHAR16_T at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_char32_t::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_CHAR32_T at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_complete_value_initialization::test())
   {
      std::cerr << "Failed test for BOOST_NO_COMPLETE_VALUE_INITIALIZATION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_constexpr::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_CONSTEXPR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_ctype_functions::test())
   {
      std::cerr << "Failed test for BOOST_NO_CTYPE_FUNCTIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cv_specializations::test())
   {
      std::cerr << "Failed test for BOOST_NO_CV_SPECIALIZATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cv_void_specializations::test())
   {
      std::cerr << "Failed test for BOOST_NO_CV_VOID_SPECIALIZATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cwchar::test())
   {
      std::cerr << "Failed test for BOOST_NO_CWCHAR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cwctype::test())
   {
      std::cerr << "Failed test for BOOST_NO_CWCTYPE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_addressof::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_ADDRESSOF at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_alignas::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_ALIGNAS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_allocator::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_ALLOCATOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_atomic_smart_ptr::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_ATOMIC_SMART_PTR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_final::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_FINAL at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_array::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_ARRAY at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_atomic::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_ATOMIC at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_chrono::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_CHRONO at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_codecvt::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_CODECVT at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_condition_variable::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_CONDITION_VARIABLE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_forward_list::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_FORWARD_LIST at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_future::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_FUTURE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_initializer_list::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_INITIALIZER_LIST at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_mutex::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_MUTEX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_random::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_RANDOM at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_ratio::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_RATIO at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_regex::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_REGEX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_system_error::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_SYSTEM_ERROR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_thread::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_THREAD at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_tuple::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_TUPLE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_type_traits::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_TYPE_TRAITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_typeindex::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_TYPEINDEX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_unordered_map::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_UNORDERED_MAP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_unordered_set::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_UNORDERED_SET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_inline_namespaces::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_INLINE_NAMESPACES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_non_public_defaulted_functions::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_numeric_limits::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_NUMERIC_LIMITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_ref_qualifiers::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_REF_QUALIFIERS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_smart_ptr::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_SMART_PTR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_std_align::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_STD_ALIGN at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_trailing_result_types::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_TRAILING_RESULT_TYPES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_user_defined_literals::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_USER_DEFINED_LITERALS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_binary_literals::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_BINARY_LITERALS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_constexpr::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_CONSTEXPR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_decltype_auto::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_DECLTYPE_AUTO at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_digit_separators::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_DIGIT_SEPARATORS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_generic_lambdas::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_GENERIC_LAMBDAS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_hdr_shared_mutex::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_HDR_SHARED_MUTEX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_initialized_lambda_captures::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_aggregate_nsdmi::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_AGGREGATE_NSDMI at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_return_type_deduction::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx14_variable_templates::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX14_VARIABLE_TEMPLATES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_hdr_functional::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_HDR_FUNCTIONAL at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_decltype::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_DECLTYPE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_decltype_n3276::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_DECLTYPE_N3276 at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_deduced_typename::test())
   {
      std::cerr << "Failed test for BOOST_DEDUCED_TYPENAME at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_defaulted_functions::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_DEFAULTED_FUNCTIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_deleted_functions::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_DELETED_FUNCTIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_dependent_nested_derivations::test())
   {
      std::cerr << "Failed test for BOOST_NO_DEPENDENT_NESTED_DERIVATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_dependent_types_in_template_value_parameters::test())
   {
      std::cerr << "Failed test for BOOST_NO_DEPENDENT_TYPES_IN_TEMPLATE_VALUE_PARAMETERS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_exception_std_namespace::test())
   {
      std::cerr << "Failed test for BOOST_NO_EXCEPTION_STD_NAMESPACE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_exceptions::test())
   {
      std::cerr << "Failed test for BOOST_NO_EXCEPTIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_explicit_function_template_arguments::test())
   {
      std::cerr << "Failed test for BOOST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_explicit_conversion_operators::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_extern_template::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_EXTERN_TEMPLATE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_fenv_h::test())
   {
      std::cerr << "Failed test for BOOST_NO_FENV_H at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_fixed_length_variadic_template_expansion_packs::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_function_template_ordering::test())
   {
      std::cerr << "Failed test for BOOST_NO_FUNCTION_TEMPLATE_ORDERING at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_function_template_default_args::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_function_type_specializations::test())
   {
      std::cerr << "Failed test for BOOST_NO_FUNCTION_TYPE_SPECIALIZATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_ms_int64_numeric_limits::test())
   {
      std::cerr << "Failed test for BOOST_NO_MS_INT64_NUMERIC_LIMITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_inclass_member_initialization::test())
   {
      std::cerr << "Failed test for BOOST_NO_INCLASS_MEMBER_INITIALIZATION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_integral_int64_t::test())
   {
      std::cerr << "Failed test for BOOST_NO_INTEGRAL_INT64_T at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_iosfwd::test())
   {
      std::cerr << "Failed test for BOOST_NO_IOSFWD at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_iostream::test())
   {
      std::cerr << "Failed test for BOOST_NO_IOSTREAM at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_is_abstract::test())
   {
      std::cerr << "Failed test for BOOST_NO_IS_ABSTRACT at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_templated_iterator_constructors::test())
   {
      std::cerr << "Failed test for BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_lambdas::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_LAMBDAS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_limits::test())
   {
      std::cerr << "Failed test for BOOST_NO_LIMITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_limits_compile_time_constants::test())
   {
      std::cerr << "Failed test for BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_long_long_numeric_limits::test())
   {
      std::cerr << "Failed test for BOOST_NO_LONG_LONG_NUMERIC_LIMITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_long_long::test())
   {
      std::cerr << "Failed test for BOOST_NO_LONG_LONG at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_member_function_specializations::test())
   {
      std::cerr << "Failed test for BOOST_NO_MEMBER_FUNCTION_SPECIALIZATIONS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_member_template_keyword::test())
   {
      std::cerr << "Failed test for BOOST_NO_MEMBER_TEMPLATE_KEYWORD at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_pointer_to_member_template_parameters::test())
   {
      std::cerr << "Failed test for BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_member_template_friends::test())
   {
      std::cerr << "Failed test for BOOST_NO_MEMBER_TEMPLATE_FRIENDS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_member_templates::test())
   {
      std::cerr << "Failed test for BOOST_NO_MEMBER_TEMPLATES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_nested_friendship::test())
   {
      std::cerr << "Failed test for BOOST_NO_NESTED_FRIENDSHIP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_noexcept::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_NOEXCEPT at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_nullptr::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_NULLPTR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_operators_in_namespace::test())
   {
      std::cerr << "Failed test for BOOST_NO_OPERATORS_IN_NAMESPACE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_partial_specialization_implicit_default_args::test())
   {
      std::cerr << "Failed test for BOOST_NO_PARTIAL_SPECIALIZATION_IMPLICIT_DEFAULT_ARGS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_template_partial_specialization::test())
   {
      std::cerr << "Failed test for BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_private_in_aggregate::test())
   {
      std::cerr << "Failed test for BOOST_NO_PRIVATE_IN_AGGREGATE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_pointer_to_member_const::test())
   {
      std::cerr << "Failed test for BOOST_NO_POINTER_TO_MEMBER_CONST at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_range_based_for::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_RANGE_BASED_FOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_raw_literals::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_RAW_LITERALS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_unreachable_return_detection::test())
   {
      std::cerr << "Failed test for BOOST_NO_UNREACHABLE_RETURN_DETECTION at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_rtti::test())
   {
      std::cerr << "Failed test for BOOST_NO_RTTI at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_rvalue_references::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_RVALUE_REFERENCES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_scoped_enums::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_SCOPED_ENUMS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_sfinae::test())
   {
      std::cerr << "Failed test for BOOST_NO_SFINAE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_sfinae_expr::test())
   {
      std::cerr << "Failed test for BOOST_NO_SFINAE_EXPR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_stringstream::test())
   {
      std::cerr << "Failed test for BOOST_NO_STRINGSTREAM at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_static_assert::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_STATIC_ASSERT at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_allocator::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_ALLOCATOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_distance::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_DISTANCE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_iterator_traits::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_ITERATOR_TRAITS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_iterator::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_ITERATOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_locale::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_LOCALE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_messages::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_MESSAGES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_min_max::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_MIN_MAX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_output_iterator_assign::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_OUTPUT_ITERATOR_ASSIGN at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_typeinfo::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_TYPEINFO at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_use_facet::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_USE_FACET at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_wstreambuf::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_WSTREAMBUF at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_std_wstring::test())
   {
      std::cerr << "Failed test for BOOST_NO_STD_WSTRING at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_stdc_namespace::test())
   {
      std::cerr << "Failed test for BOOST_NO_STDC_NAMESPACE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_swprintf::test())
   {
      std::cerr << "Failed test for BOOST_NO_SWPRINTF at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_local_class_template_parameters::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_template_aliases::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_TEMPLATE_ALIASES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_templated_iostreams::test())
   {
      std::cerr << "Failed test for BOOST_NO_TEMPLATED_IOSTREAMS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_template_templates::test())
   {
      std::cerr << "Failed test for BOOST_NO_TEMPLATE_TEMPLATES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_two_phase_name_lookup::test())
   {
      std::cerr << "Failed test for BOOST_NO_TWO_PHASE_NAME_LOOKUP at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_typeid::test())
   {
      std::cerr << "Failed test for BOOST_NO_TYPEID at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_typename_with_ctor::test())
   {
      std::cerr << "Failed test for BOOST_NO_TYPENAME_WITH_CTOR at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_unicode_literals::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_UNICODE_LITERALS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_unified_initialization_syntax::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_function_scope_using_declaration_breaks_adl::test())
   {
      std::cerr << "Failed test for BOOST_FUNCTION_SCOPE_USING_DECLARATION_BREAKS_ADL at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_using_declaration_overloads_from_typename_base::test())
   {
      std::cerr << "Failed test for BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_using_template::test())
   {
      std::cerr << "Failed test for BOOST_NO_USING_TEMPLATE at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_variadic_macros::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_VARIADIC_MACROS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_cxx11_variadic_templates::test())
   {
      std::cerr << "Failed test for BOOST_NO_CXX11_VARIADIC_TEMPLATES at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_void_returns::test())
   {
      std::cerr << "Failed test for BOOST_NO_VOID_RETURNS at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   if(0 != boost_no_intrinsic_wchar_t::test())
   {
      std::cerr << "Failed test for BOOST_NO_INTRINSIC_WCHAR_T at: " << __FILE__ << ":" << __LINE__ << std::endl;
      ++error_count;
   }
   return error_count;
}


text:
#ifndef _MSC_VER
#include "update_ops_cpp.hpp"
extern "C"{
#include "utility.h"
}
#else
#include "update_ops_cpp.hpp"
#include "utility.h"
#endif
#include <Eigen/Core>
#include <functional>

void multi_qubit_dense_matrix_gate_eigen(const UINT* target_qubit_index_list, UINT target_qubit_index_count, const CTYPE* matrix, CTYPE* state, ITYPE dim) {

    // matrix dim, mask, buffer
    const ITYPE matrix_dim = 1ULL << target_qubit_index_count;
    const ITYPE* matrix_mask_list = create_matrix_mask_list(target_qubit_index_list, target_qubit_index_count);
    Eigen::Map<const Eigen::Matrix<std::complex<double>,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>, Eigen::Aligned> eigen_matrix((std::complex<double>*)matrix,matrix_dim,matrix_dim);
    Eigen::VectorXcd buffer(matrix_dim);
    std::complex<double>* eigen_state = reinterpret_cast<std::complex<double>*>(state);

    // insert index
    const UINT* sorted_insert_index_list = create_sorted_ui_list(target_qubit_index_list, target_qubit_index_count);

    // loop variables
    const ITYPE loop_dim = dim >> target_qubit_index_count;

    ITYPE state_index;
    for(state_index = 0 ; state_index < loop_dim ; ++state_index ){
        // create base index
        ITYPE basis_0 = state_index;
        for(UINT cursor=0; cursor < target_qubit_index_count ; cursor++){
            UINT insert_index = sorted_insert_index_list[cursor];
            basis_0 = insert_zero_to_basis_index(basis_0, 1ULL << insert_index , insert_index );
        }

        // fetch vector
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            buffer[y] = eigen_state[basis_0 ^ matrix_mask_list[y]];
        }

        buffer = eigen_matrix * buffer;

        // set result
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            eigen_state[basis_0 ^ matrix_mask_list[y]] = buffer[y];
        }
    }
    free((UINT*)sorted_insert_index_list);
    free((ITYPE*)matrix_mask_list);
}

void multi_qubit_dense_matrix_gate_eigen(const UINT* target_qubit_index_list, UINT target_qubit_index_count, const Eigen::Matrix<std::complex<double>,Eigen::Dynamic,Eigen::Dynamic,Eigen::RowMajor>& eigen_matrix, CTYPE* state, ITYPE dim){
    // matrix dim, mask, buffer
    const ITYPE matrix_dim = 1ULL << target_qubit_index_count;
    const ITYPE* matrix_mask_list = create_matrix_mask_list(target_qubit_index_list, target_qubit_index_count);
    Eigen::VectorXcd buffer(matrix_dim);
    std::complex<double>* eigen_state = reinterpret_cast<std::complex<double>*>(state);

    // insert index
    const UINT* sorted_insert_index_list = create_sorted_ui_list(target_qubit_index_list, target_qubit_index_count);

    // loop variables
    const ITYPE loop_dim = dim >> target_qubit_index_count;

    ITYPE state_index;
    for(state_index = 0 ; state_index < loop_dim ; ++state_index ){
        // create base index
        ITYPE basis_0 = state_index;
        for(UINT cursor=0; cursor < target_qubit_index_count ; cursor++){
            UINT insert_index = sorted_insert_index_list[cursor];
            basis_0 = insert_zero_to_basis_index(basis_0, 1ULL << insert_index , insert_index );
        }

        // fetch vector
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            buffer[y] = eigen_state[basis_0 ^ matrix_mask_list[y]];
        }

        buffer = eigen_matrix * buffer;

        // set result
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            eigen_state[basis_0 ^ matrix_mask_list[y]] = buffer[y];
        }
    }
    free((UINT*)sorted_insert_index_list);
    free((ITYPE*)matrix_mask_list);
}

void multi_qubit_dense_matrix_gate_eigen(const UINT* target_qubit_index_list, UINT target_qubit_index_count, const Eigen::MatrixXcd& eigen_matrix, CTYPE* state, ITYPE dim) {

    // matrix dim, mask, buffer
    const ITYPE matrix_dim = 1ULL << target_qubit_index_count;
    const ITYPE* matrix_mask_list = create_matrix_mask_list(target_qubit_index_list, target_qubit_index_count);
    std::complex<double>* cppstate = reinterpret_cast<std::complex<double>*>(state);
    Eigen::VectorXcd buffer(matrix_dim);

    // insert index
    const UINT* sorted_insert_index_list = create_sorted_ui_list(target_qubit_index_list, target_qubit_index_count);

    // loop variables
    const ITYPE loop_dim = dim >> target_qubit_index_count;

    ITYPE state_index;
    for(state_index = 0 ; state_index < loop_dim ; ++state_index ){
        // create base index
        ITYPE basis_0 = state_index;
        for(UINT cursor=0; cursor < target_qubit_index_count ; cursor++){
            UINT insert_index = sorted_insert_index_list[cursor];
            basis_0 = insert_zero_to_basis_index(basis_0, 1ULL << insert_index , insert_index );
        }

        // fetch vector
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            buffer[y] = cppstate[basis_0 ^ matrix_mask_list[y]];
        }

        buffer = eigen_matrix * buffer;

        // set result
        for(ITYPE y = 0 ; y < matrix_dim ; ++y){
            cppstate[basis_0 ^ matrix_mask_list[y]] = buffer[y];
        }
    }
    free((UINT*)sorted_insert_index_list);
    free((ITYPE*)matrix_mask_list);
}

void multi_qubit_sparse_matrix_gate_eigen(const UINT* target_qubit_index_list, UINT target_qubit_index_count, const Eigen::SparseMatrix<std::complex<double>>& eigen_matrix, CTYPE* state, ITYPE dim) {
	// matrix dim, mask, buffer
	const ITYPE matrix_dim = 1ULL << target_qubit_index_count;
	const ITYPE* matrix_mask_list = create_matrix_mask_list(target_qubit_index_list, target_qubit_index_count);
	Eigen::VectorXcd buffer(matrix_dim);
	std::complex<double>* eigen_state = reinterpret_cast<std::complex<double>*>(state);

	// insert index
	const UINT* sorted_insert_index_list = create_sorted_ui_list(target_qubit_index_list, target_qubit_index_count);

	// loop variables
	const ITYPE loop_dim = dim >> target_qubit_index_count;

	ITYPE state_index;
	for (state_index = 0; state_index < loop_dim; ++state_index) {
		// create base index
		ITYPE basis_0 = state_index;
		for (UINT cursor = 0; cursor < target_qubit_index_count; cursor++) {
			UINT insert_index = sorted_insert_index_list[cursor];
			basis_0 = insert_zero_to_basis_index(basis_0, 1ULL << insert_index, insert_index);
		}

		// fetch vector
		for (ITYPE y = 0; y < matrix_dim; ++y) {
			buffer[y] = eigen_state[basis_0 ^ matrix_mask_list[y]];
		}

		buffer = eigen_matrix * buffer;

		// set result
		for (ITYPE y = 0; y < matrix_dim; ++y) {
			eigen_state[basis_0 ^ matrix_mask_list[y]] = buffer[y];
		}
	}
	free((UINT*)sorted_insert_index_list);
	free((ITYPE*)matrix_mask_list);
}

void reversible_boolean_gate(const UINT* target_qubit_index_list, UINT target_qubit_index_count, std::function<ITYPE(ITYPE,ITYPE)> function_ptr, CTYPE* state, ITYPE dim) {

	// matrix dim, mask, buffer
	const ITYPE matrix_dim = 1ULL << target_qubit_index_count;
	const ITYPE* matrix_mask_list = create_matrix_mask_list(target_qubit_index_list, target_qubit_index_count);

	// insert index
	const UINT* sorted_insert_index_list = create_sorted_ui_list(target_qubit_index_list, target_qubit_index_count);

	// loop variables
	const ITYPE loop_dim = dim >> target_qubit_index_count;

	CTYPE* buffer = (CTYPE*)malloc((size_t)(sizeof(CTYPE)*matrix_dim));
	ITYPE state_index;
	for (state_index = 0; state_index < loop_dim; ++state_index) {
		// create base index
		ITYPE basis_0 = state_index;
		for (UINT cursor = 0; cursor < target_qubit_index_count; cursor++) {
			UINT insert_index = sorted_insert_index_list[cursor];
			basis_0 = insert_zero_to_basis_index(basis_0, 1ULL << insert_index, insert_index);
		}

		// compute matrix-vector multiply

		for (ITYPE x = 0; x < matrix_dim; ++x) {
			ITYPE y = function_ptr(x, matrix_dim);
			buffer[y] = state[basis_0 ^ matrix_mask_list[x]];
		}

		// set result
		for (ITYPE y = 0; y < matrix_dim; ++y) {
			state[basis_0 ^ matrix_mask_list[y]] = buffer[y];
		}
	}
	free(buffer);
	free((UINT*)sorted_insert_index_list);
	free((ITYPE*)matrix_mask_list);
}

ext: cpp

max_stars_repo_name: yoooopeeee/qulacs

max_issues_repo_name: yoooopeeee/qulacs

max_forks_repo_name: yoooopeeee/qulacs


text:
#include "file_task_store.hpp"

#include <string_view>
#include <filesystem>
#include <fstream>
#include <boost/json.hpp>
#include <boost/uuid/uuid_io.hpp>
#include <boost/uuid/string_generator.hpp>
#include <spdlog/spdlog.h>

namespace json = boost::json;
namespace fs = std::filesystem;

using namespace common::scheduler;

namespace common::scheduler
{
//Serialize
void tag_invoke(json::value_from_tag, json::value& jv, const TaskEntity& task)
{
  using std::to_string;
  jv = {
    { "id", to_string(task.id) },
    { "owner", task.owner },
    { "timestamp", task.timestamp }
  };
}

//Deserialize
TaskEntity tag_invoke(json::value_to_tag<TaskEntity>, const json::value& jv)
{
  auto string_gen = boost::uuids::string_generator{};
  const json::object& obj = jv.as_object();
  return TaskEntity {
      string_gen(json::value_to<std::string>( obj.at("id"))),
      json::value_to<std::string>(obj.at("owner" )),
      json::value_to<std::int64_t>(obj.at( "timestamp"))
  };
}

FileTaskStore::FileTaskStore(std::string fpath)
  : filepath_{std::move(fpath)}
{
  if (!fs::exists(filepath_)) {
    auto file = std::fstream{filepath_, std::ios::out};
    store();
  }

  load();
}

void FileTaskStore::add(TaskEntity entity)
{
  auto e = std::find_if(cached_tasks_.begin(), cached_tasks_.end(), [&entity](const auto& x) {
    return entity.id == x.id;
  });

  if (e != cached_tasks_.end()) {
    throw std::runtime_error("Task already exist.");
  }

  cached_tasks_.push_back(std::move(entity));
  store();
  load();
}

bool FileTaskStore::exist(const TaskEntity::Id_t& id) const
{
  return std::find_if(cached_tasks_.begin(), cached_tasks_.end(), [&id](const auto& x) {
    return id == x.id;
  }) != cached_tasks_.end();
}

std::optional<TaskEntity> FileTaskStore::find(const TaskEntity::Id_t& id) const //TODO: Consider returning different type
{
  auto e = std::find_if(cached_tasks_.begin(), cached_tasks_.end(), [&id](const auto& x) {
    return id == x.id;
  });

  if (e == cached_tasks_.end()) {
    return std::nullopt;
  } else {
    return {*e};
  }
}

void FileTaskStore::remove(const TaskEntity::Id_t& id)
{
  auto e = std::find_if(cached_tasks_.begin(), cached_tasks_.end(), [&id](const auto& x) {
    return id == x.id;
  });

  if (e == cached_tasks_.end()) {
    throw std::runtime_error("Task does not exist");
  }

  cached_tasks_.erase(e);
  store();
  load();
}

void FileTaskStore::load()
{
  auto file = std::fstream(filepath_, std::ios::in);
  if (!file) {
    throw std::runtime_error("Error while reading file.");
  }
  auto parser = json::stream_parser{};
  auto error_code = json::error_code{};

  do {
    auto buffer = std::array<char, 4096>{};
    file.read(buffer.begin(), buffer.size());
    parser.write(buffer.data(), file.gcount(), error_code);
  } while(!file.eof());

  if (error_code) {
    throw std::runtime_error("Error while reading file.");
  }
  parser.finish(error_code);

  if (error_code) {
    throw std::runtime_error("Error while parsing file. File may be malformed.");
  }

  //Todo: Consider more efficient way to update values, monotonic buffers etc
  cached_tasks_ = json::value_to<std::vector<TaskEntity>>(parser.release());
}

void FileTaskStore::store()
{
  auto file = std::fstream(filepath_, std::ios::out);
  if (!file) {
    throw std::runtime_error("Error while writing to file.");
  }

  file << json::serialize(json::value_from(cached_tasks_));
}

}

max_stars_repo_name: pblxptr/hhctrl-management

max_issues_repo_name: pblxptr/hhctrl-management

max_forks_repo_name: pblxptr/hhctrl-management


text:
#ifndef IMGEN_IMGEN_HPP_
#define IMGEN_IMGEN_HPP_

#include "imgen/image.hpp"
#include "imgen/palette.hpp"
#include "imgen/pattern.hpp"

#include <Python.h>
#include <boost/filesystem.hpp>
#include <boost/python.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>

#include <string>

namespace py = boost::python;
namespace fs = boost::filesystem;

namespace imgen {

class imgen {
    py::object main_module;
    py::dict main_nmspc;
    fs::path working_dir;
    palette_linker pal_linker;
    pattern_linker pat_linker;
    boost::shared_ptr<palette> pal;
    boost::shared_ptr<pattern> pat;

public:
    imgen(fs::path wdir);

    void set_seed(unsigned seed);
    void generate(const fs::path& dest, unsigned width, unsigned height);
    void set_palette(const std::string& name);
    void set_pattern(const std::string& name);
    std::string random_palette();
    std::string random_pattern();

private:
    static constexpr auto MODULE_DIR  = "python/";
    static constexpr auto PALETTE_DIR = "palettes/";
    static constexpr auto PATTERN_DIR = "patterns/";

    void import(const std::string& module);
    void add_to_path(const fs::path& dir);
};

} // namespace imgen

#endif // IMGEN_IMGEN_HPP_

ext: hpp

max_stars_repo_name: maddisoj/wallgen

max_issues_repo_name: maddisoj/wallgen

max_forks_repo_name: maddisoj/wallgen


text:
#ifndef BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819
#define BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819

// Copyright 2011 Dean Michael Berris (dberris@google.com).
// Copyright 2011 Google, 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)

#include <cstdint>
#include <functional>
#include <boost/asio/ssl.hpp>
#include <boost/network/protocol/http/client/connection/ssl_delegate.hpp>

boost::network::http::impl::ssl_delegate::ssl_delegate(
    boost::asio::io_service &service, bool always_verify_peer,
    optional<std::string> certificate_filename,
    optional<std::string> verify_path, optional<std::string> certificate_file,
    optional<std::string> private_key_file, optional<std::string> ciphers,
    optional<std::string> sni_hostname, long ssl_options)
    : service_(service),
      certificate_filename_(std::move(certificate_filename)),
      verify_path_(std::move(verify_path)),
      certificate_file_(std::move(certificate_file)),
      private_key_file_(std::move(private_key_file)),
      ciphers_(std::move(ciphers)),
      sni_hostname_(std::move(sni_hostname)),
      ssl_options_(ssl_options),
      always_verify_peer_(always_verify_peer) {}

void boost::network::http::impl::ssl_delegate::connect(
    boost::asio::ip::tcp::endpoint &endpoint, std::string host,
    std::uint16_t source_port,
    std::function<void(boost::system::error_code const &)> handler) {
  context_.reset(
      new boost::asio::ssl::context(boost::asio::ssl::context::method::sslv23_client));
  if (ciphers_) {
    ::SSL_CTX_set_cipher_list(context_->native_handle(), ciphers_->c_str());
  }
  if (ssl_options_ != 0) {
    context_->set_options(ssl_options_);
  } else {
    // By default, disable v3 support.
    context_->set_options(boost::asio::ssl::context::no_sslv3);
  }
  if (certificate_filename_ || verify_path_) {
    context_->set_verify_mode(boost::asio::ssl::context::verify_peer);
    if (certificate_filename_)
      context_->load_verify_file(*certificate_filename_);
    if (verify_path_) context_->add_verify_path(*verify_path_);
  } else {
    if (always_verify_peer_) {
      context_->set_verify_mode(boost::asio::ssl::context::verify_peer);
      // use openssl default verify paths.  uses openssl environment variables
      // SSL_CERT_DIR, SSL_CERT_FILE
      context_->set_default_verify_paths();
    } else {
      context_->set_verify_mode(boost::asio::ssl::context::verify_none);
    }
  }
  if (certificate_file_)
    context_->use_certificate_file(*certificate_file_, boost::asio::ssl::context::pem);
  if (private_key_file_)
    context_->use_private_key_file(*private_key_file_, boost::asio::ssl::context::pem);

  tcp_socket_.reset(new boost::asio::ip::tcp::socket(
      service_, boost::asio::ip::tcp::endpoint(boost::asio::ip::tcp::v4(), source_port)));
  socket_.reset(new boost::asio::ssl::stream<boost::asio::ip::tcp::socket &>(
      *(tcp_socket_.get()), *context_));

  if (sni_hostname_)
    SSL_set_tlsext_host_name(socket_->native_handle(), sni_hostname_->c_str());
  if (always_verify_peer_)
    socket_->set_verify_callback(boost::asio::ssl::rfc2818_verification(host));
  auto self = this->shared_from_this();
  socket_->lowest_layer().async_connect(
      endpoint,
      [=](boost::system::error_code const &ec) { self->handle_connected(ec, handler); });
}

void boost::network::http::impl::ssl_delegate::handle_connected(
    boost::system::error_code const &ec,
    std::function<void(boost::system::error_code const &)> handler) {
  if (!ec) {
    socket_->async_handshake(boost::asio::ssl::stream_base::client, handler);
  } else {
    handler(ec);
  }
}

void boost::network::http::impl::ssl_delegate::write(
    boost::asio::streambuf &command_streambuf,
    std::function<void(boost::system::error_code const &, size_t)> handler) {
  boost::asio::async_write(*socket_, command_streambuf, handler);
}

void boost::network::http::impl::ssl_delegate::read_some(
    boost::asio::mutable_buffers_1 const &read_buffer,
    std::function<void(boost::system::error_code const &, size_t)> handler) {
  socket_->async_read_some(read_buffer, handler);
}

void boost::network::http::impl::ssl_delegate::disconnect() {
  if (socket_.get() && socket_->lowest_layer().is_open()) {
    boost::system::error_code ignored;
    socket_->lowest_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both,
                                     ignored);
    if (!ignored) {
      socket_->lowest_layer().close(ignored);
    }
  }
}

boost::network::http::impl::ssl_delegate::~ssl_delegate() {}

#endif  // BOOST_NETWORK_PROTOCOL_HTTP_CLIENT_CONNECTION_SSL_DELEGATE_IPP_20110819

ext: ipp

max_stars_repo_name: yhager/cpp-netlib

max_issues_repo_name: yhager/cpp-netlib

max_forks_repo_name: yhager/cpp-netlib


text:
#ifndef CLAMMBON_GUI_HPP
#define CLAMMBON_GUI_HPP

#include <future>
#include <boost/thread.hpp>
#include "data_type.hpp"
#include "splitter.hpp"

namespace gui
{
    namespace impl{ class MoveWindow; }

    // GUI Thread係
    class manager : boost::noncopyable {
    public:
        typedef boost::shared_ptr<impl::MoveWindow> window_ptr;
        manager(std::function<void(std::vector<std::vector<point_type>> const&)> const& callback);
        virtual ~manager();

        void wait_all_window();
        void push_back(std::function<window_ptr()> const& func);

    private:
        std::mutex mutex_;
        std::unique_ptr<boost::thread> th_;

        std::vector<std::function<window_ptr()>> queue_;
        std::vector<window_ptr> windows_;
    };

    boost::shared_ptr<impl::MoveWindow> make_mansort_window(
        split_image_type const& splitted,
        std::vector<std::vector<point_type>> const& default_position,
        std::string const& window_name = ""
        );

    boost::shared_ptr<impl::MoveWindow> make_mansort_window(
        split_image_type const& splitted,
        std::string const& window_name = ""
        );

    boost::optional<std::vector<std::vector<point_type>>> get_result(boost::shared_ptr<impl::MoveWindow>& ptr);
    bool is_hide_window(boost::shared_ptr<impl::MoveWindow>& ptr);

	void combine_show_image(question_raw_data const& data_, compared_type const& comp_, std::vector<answer_type_y> const& answer);
	void combine_show_image(question_raw_data const& data_, compared_type const& comp_, std::vector<std::vector<point_type>>const& matrix);
	void combine_show_image(question_raw_data const& data_, compared_type const& comp_, std::vector<std::vector<std::vector<point_type>>> const& matrix);
	void combine_show_image(question_raw_data const& data_, compared_type const& comp_, std::vector<std::vector<point_type>>const& matrix,std::ostringstream const outname);

	void show_image(question_raw_data const& data_, compared_type const& comp_, std::vector<answer_type_y> const& answer);

} // namespace gui

#endif


text:
// Copyright (c) 2009, Object Computing, Inc.
// All rights reserved.
// See the file license.txt for licensing information.
#include <Common/QuickFASTPch.h>

#define BOOST_TEST_NO_MAIN QuickFASTTest
#include <boost/test/unit_test.hpp>
#include <Codecs/XMLTemplateParser.h>
#include <Codecs/DataDestination.h>
#include <Codecs/DataSourceString.h>
#include <Codecs/TemplateRegistry.h>
#include <Codecs/Decoder.h>
#include <Codecs/Encoder.h>
#include <Messages/FieldDecimal.h>
#include <Messages/FieldSequence.h>
#include <Messages/Sequence.h>
#include <Messages/FieldIdentity.h>
#include <Codecs/GenericMessageBuilder.h>
#include <Codecs/SingleMessageConsumer.h>

using namespace QuickFAST;

namespace
{
  const char * templates =
    "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"
    "<templates xmlns=\"http://www.fixprotocol.org/ns/fast/td/1.1\">"
    "    <template name=\"Test1Message\" id=\"5000\" xmlns=\"http://www.fixprotocol.org/ns/fast/td/1.1\">"
    "        <sequence name=\"Parties\">"
    "            <length name=\"NoParties\" id=\"9998\"/>"
    "            <sequence name=\"Entries\">"
    "                <length name=\"NoEntries\" id=\"9997\"/>"
    "                <decimal name=\"Price\" id=\"80\"><copy/></decimal>"
    "            </sequence>"
    "        </sequence>"
    "    </template>"
    "    <template name=\"Test2Message\" id=\"4000\" xmlns=\"http://www.fixprotocol.org/ns/fast/td/1.1\">"
    "        <sequence name=\"Entries\">"
    "            <length name=\"NoEntries\" id=\"8997\"/>"
    "            <decimal name=\"Price\" id=\"70\"><copy/></decimal>"
    "        </sequence>"
    "    </template>"
    "</templates>"
    ;

}

namespace{
  Messages::FieldIdentity noParties("NoParties");
  Messages::FieldIdentity noEntries("NoEntries");

  Messages::FieldIdentity priceIdentity("Price");
  Messages::FieldIdentity entriesIdentity("Entries");
  Messages::FieldIdentity partiesIdentity("Parties");

}

BOOST_AUTO_TEST_CASE(testNestedSequences)
{
  BOOST_TEST_PASSPOINT();
  std::stringstream templateStream(templates);
  Codecs::XMLTemplateParser parser;
  Codecs::TemplateRegistryPtr templateRegistry = parser.parse(templateStream);
//  templateRegistry->display(std::cout);

  Codecs::Encoder enc(templateRegistry);
  Codecs::Decoder dec(templateRegistry);

  Messages::FieldSetPtr msg(new Messages::FieldSet(20));
  Messages::SequencePtr parties(new Messages::Sequence(noParties, 20));
  Messages::FieldSetPtr p1(new Messages::FieldSet(20));
  Messages::SequencePtr entries(new Messages::Sequence(noEntries, 20));
  Messages::FieldSetPtr e1(new Messages::FieldSet(20));

  e1->addField( priceIdentity,
    Messages::FieldDecimal::create(Decimal(1, -1)) ); //(1, 0) is ok

  entries->addEntry(e1);
  entries->addEntry(e1);
  entries->addEntry(e1);

  p1->addField( entriesIdentity,
    Messages::FieldSequence::create(entries) );

  parties->addEntry(p1);
  parties->addEntry(p1);
  parties->addEntry(p1);

  msg->addField(partiesIdentity,
    Messages::FieldSequence::create(parties) );

  Codecs::TemplateCPtr tpl;

  BOOST_REQUIRE(enc.findTemplate("Test1Message", "", tpl));
  Codecs::DataDestination dest;
  enc.encodeMessage(dest, tpl->getId(), *msg);
//  std::cout << "encoded" << std::endl;

  std::string encodedValue;
  dest.toString(encodedValue);
  Codecs::DataSourceString src(encodedValue);
  Codecs::SingleMessageConsumer consumer;
  Codecs::GenericMessageBuilder builder(consumer);
  dec.decodeMessage(src, builder);
//  std::cout << "decoded" << std::endl;

  Messages::Message & message = consumer.message();

  Messages::FieldCPtr decodedParties;
  message.getField("Parties", decodedParties);
  BOOST_REQUIRE(decodedParties);
  Messages::SequenceCPtr decodedPartiesSequence = decodedParties->toSequence();
  BOOST_REQUIRE(decodedPartiesSequence);

  Messages::FieldSetCPtr decodedPartyItem = (*decodedPartiesSequence)[0];
  BOOST_REQUIRE(decodedPartyItem);

  // now get the nested sequence
  Messages::FieldCPtr decodedEntries;
  decodedPartyItem->getField("Entries", decodedEntries);
  Messages::SequenceCPtr decodedEntriesSequence = decodedEntries->toSequence();
  BOOST_REQUIRE(decodedEntriesSequence);

  Messages::FieldSetCPtr decodedEntry = (*decodedEntriesSequence)[0];
  BOOST_REQUIRE(decodedEntry);

  Messages::FieldCPtr decodedPrice;
  decodedEntry->getField("Price", decodedPrice);
  BOOST_REQUIRE(decodedPrice);
  BOOST_CHECK_EQUAL(decodedPrice->toDecimal(), Decimal(1,-1));
}


text:
//==============================================================================
//         Copyright 2003 - 2011 LASMEA UMR 6602 CNRS/Univ. Clermont II
//         Copyright 2009 - 2011 LRI    UMR 8623 CNRS/Univ Paris Sud XI
//
//          Distributed under the Boost Software License, Version 1.0.
//                 See accompanying file LICENSE.txt or copy at
//                     http://www.boost.org/LICENSE_1_0.txt
//==============================================================================
#ifndef BOOST_SIMD_REDUCTION_FUNCTIONS_SIMD_SSE_SSE2_ALL_HPP_INCLUDED
#define BOOST_SIMD_REDUCTION_FUNCTIONS_SIMD_SSE_SSE2_ALL_HPP_INCLUDED
#ifdef BOOST_SIMD_HAS_SSE2_SUPPORT

#include <boost/simd/reduction/functions/all.hpp>
#include <boost/simd/include/functions/simd/genmask.hpp>
#include <boost/simd/sdk/simd/logical.hpp>

namespace boost { namespace simd { namespace ext
{
  BOOST_SIMD_FUNCTOR_IMPLEMENTATION(boost::simd::tag::all_, boost::simd::tag::sse2_,
                              (A0),
                              ((simd_<type16_<A0>,boost::simd::tag::sse_>))
                            )
  {
    typedef typename meta::scalar_of<A0>::type sA0;
    typedef typename meta::as_logical<sA0>::type result_type;
    BOOST_SIMD_FUNCTOR_CALL(1)
    {
      return result_type(_mm_movemask_epi8(genmask(a0)) == 0xFFFF);
    }
  };
} } }

#endif
#endif