├── .Rbuildignore ├── .aspell ├── DBI.rds └── defaults.R ├── .github ├── .gitignore ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── ISSUE_TEMPLATE.md ├── move.yml ├── security.md ├── versions-matrix.R └── workflows │ ├── R-CMD-check-dev.yaml │ ├── R-CMD-check-status.yaml │ ├── R-CMD-check.yaml │ ├── check │ └── action.yml │ ├── commit │ └── action.yml │ ├── covr │ └── action.yml │ ├── custom │ ├── after-install │ │ └── action.yml │ └── before-install │ │ └── action.yml │ ├── dep-matrix │ └── action.yml │ ├── dep-suggests-matrix │ ├── action.R │ └── action.yml │ ├── fledge.yaml │ ├── get-extra │ └── action.yml │ ├── ghcr.yaml │ ├── git-identity │ └── action.yml │ ├── install │ └── action.yml │ ├── lock.yaml │ ├── matrix-check │ └── action.yml │ ├── pkgdown-build │ └── action.yml │ ├── pkgdown-deploy │ └── action.yml │ ├── pkgdown.yaml │ ├── pr-commands.yaml │ ├── rate-limit │ └── action.yml │ ├── revdep.yaml │ ├── roxygenize │ └── action.yml │ ├── style │ └── action.yml │ ├── update-snapshots │ └── action.yml │ └── versions-matrix │ ├── action.R │ └── action.yml ├── .gitignore ├── .gitpod.yml ├── CMakeLists.txt ├── DESCRIPTION ├── Dockerfile ├── LICENSE ├── LICENSE.md ├── NAMESPACE ├── NEWS.md ├── R ├── PqConnection.R ├── PqDriver.R ├── PqResult.R ├── RPostgres-pkg.R ├── Redshift.R ├── cpp11.R ├── dbAppendTable_PqConnection.R ├── dbBegin_PqConnection.R ├── dbBind_PqResult.R ├── dbClearResult_PqResult.R ├── dbColumnInfo_PqResult.R ├── dbCommit_PqConnection.R ├── dbConnect_PqDriver.R ├── dbConnect_RedshiftDriver.R ├── dbDataType_PqConnection.R ├── dbDataType_PqDriver.R ├── dbDisconnect_PqConnection.R ├── dbExistsTable_PqConnection_Id.R ├── dbExistsTable_PqConnection_character.R ├── dbFetch_PqResult.R ├── dbGetInfo_PqConnection.R ├── dbGetInfo_PqDriver.R ├── dbGetRowCount_PqResult.R ├── dbGetRowsAffected_PqResult.R ├── dbGetStatement_PqResult.R ├── dbHasCompleted_PqResult.R ├── dbIsValid_PqConnection.R ├── dbIsValid_PqDriver.R ├── dbIsValid_PqResult.R ├── dbListFields_PqConnection_Id.R ├── dbListFields_PqConnection_character.R ├── dbListObjects_PqConnection_ANY.R ├── dbListTables_PqConnection.R ├── dbQuoteIdentifier_PqConnection_Id.R ├── dbQuoteIdentifier_PqConnection_SQL.R ├── dbQuoteIdentifier_PqConnection_character.R ├── dbQuoteLiteral_PqConnection.R ├── dbQuoteString_PqConnection_SQL.R ├── dbQuoteString_PqConnection_character.R ├── dbReadTable_PqConnection_character.R ├── dbRemoveTable_PqConnection_character.R ├── dbRollback_PqConnection.R ├── dbSendQuery_PqConnection.R ├── dbUnloadDriver_PqDriver.R ├── dbUnquoteIdentifier_PqConnection_SQL.R ├── dbWriteTable_PqConnection_character_data.frame.R ├── default.R ├── export.R ├── quote.R ├── show_PqConnection.R ├── sqlData_PqConnection.R ├── tables.R ├── transactions.R └── utils.R ├── README.md ├── RPostgres.Rproj ├── _pkgdown.yml ├── codecov.yml ├── configure ├── configure.win ├── cran-comments.md ├── docker-compose.yml ├── man ├── Postgres.Rd ├── PqConnection-class.Rd ├── PqDriver-class.Rd ├── PqResult-class.Rd ├── RPostgres-package.Rd ├── Redshift.Rd ├── dbDataType.Rd ├── postgres-query.Rd ├── postgres-tables.Rd ├── postgres-transactions.Rd ├── postgresHasDefault.Rd ├── postgresImportLargeObject.Rd ├── postgresIsTransacting.Rd ├── postgresWaitForNotify.Rd ├── quote.Rd └── reexports.Rd ├── src ├── .gitignore ├── CMakeLists.txt ├── DbColumn.cpp ├── DbColumn.h ├── DbColumnDataSource.cpp ├── DbColumnDataSource.h ├── DbColumnDataSourceFactory.cpp ├── DbColumnDataSourceFactory.h ├── DbColumnDataType.h ├── DbColumnStorage.cpp ├── DbColumnStorage.h ├── DbConnection.cpp ├── DbConnection.h ├── DbDataFrame.cpp ├── DbDataFrame.h ├── DbResult.cpp ├── DbResult.h ├── DbResultImpl.h ├── DbResultImplDecl.h ├── Makevars.in ├── Makevars.win ├── PqColumnDataSource.cpp ├── PqColumnDataSource.h ├── PqColumnDataSourceFactory.cpp ├── PqColumnDataSourceFactory.h ├── PqDataFrame.cpp ├── PqDataFrame.h ├── PqResult.cpp ├── PqResult.h ├── PqResultImpl.cpp ├── PqResultImpl.h ├── PqResultSource.cpp ├── PqResultSource.h ├── PqUtils.cpp ├── PqUtils.h ├── RPostgres-init.c ├── RPostgres_types.h ├── connection.cpp ├── cpp11.cpp ├── custom.cmake ├── encode.cpp ├── encode.h ├── encrypt.cpp ├── integer64.h ├── logging.cpp ├── pch.h ├── result.cpp └── vendor │ └── boost │ ├── array.hpp │ ├── assert.hpp │ ├── assert │ └── source_location.hpp │ ├── bind.hpp │ ├── bind │ ├── arg.hpp │ ├── bind.hpp │ ├── bind_cc.hpp │ ├── bind_mf2_cc.hpp │ ├── bind_mf_cc.hpp │ ├── bind_template.hpp │ ├── detail │ │ └── result_traits.hpp │ ├── mem_fn.hpp │ ├── mem_fn_cc.hpp │ ├── mem_fn_template.hpp │ ├── mem_fn_vw.hpp │ ├── placeholders.hpp │ ├── std_placeholders.hpp │ └── storage.hpp │ ├── call_traits.hpp │ ├── checked_delete.hpp │ ├── compressed_pair.hpp │ ├── concept │ ├── assert.hpp │ ├── detail │ │ ├── backward_compatibility.hpp │ │ ├── borland.hpp │ │ ├── concept_def.hpp │ │ ├── concept_undef.hpp │ │ ├── general.hpp │ │ ├── has_constraints.hpp │ │ └── msvc.hpp │ └── usage.hpp │ ├── concept_check.hpp │ ├── config.hpp │ ├── config │ ├── abi │ │ ├── borland_prefix.hpp │ │ ├── borland_suffix.hpp │ │ ├── msvc_prefix.hpp │ │ └── msvc_suffix.hpp │ ├── abi_prefix.hpp │ ├── abi_suffix.hpp │ ├── assert_cxx03.hpp │ ├── assert_cxx11.hpp │ ├── assert_cxx14.hpp │ ├── assert_cxx17.hpp │ ├── assert_cxx20.hpp │ ├── assert_cxx98.hpp │ ├── auto_link.hpp │ ├── compiler │ │ ├── borland.hpp │ │ ├── clang.hpp │ │ ├── clang_version.hpp │ │ ├── codegear.hpp │ │ ├── comeau.hpp │ │ ├── common_edg.hpp │ │ ├── compaq_cxx.hpp │ │ ├── cray.hpp │ │ ├── diab.hpp │ │ ├── digitalmars.hpp │ │ ├── gcc.hpp │ │ ├── gcc_xml.hpp │ │ ├── greenhills.hpp │ │ ├── hp_acc.hpp │ │ ├── intel.hpp │ │ ├── kai.hpp │ │ ├── metrowerks.hpp │ │ ├── mpw.hpp │ │ ├── nvcc.hpp │ │ ├── pathscale.hpp │ │ ├── pgi.hpp │ │ ├── sgi_mipspro.hpp │ │ ├── sunpro_cc.hpp │ │ ├── vacpp.hpp │ │ ├── visualc.hpp │ │ ├── xlcpp.hpp │ │ └── xlcpp_zos.hpp │ ├── detail │ │ ├── cxx_composite.hpp │ │ ├── posix_features.hpp │ │ ├── select_compiler_config.hpp │ │ ├── select_platform_config.hpp │ │ ├── select_stdlib_config.hpp │ │ └── suffix.hpp │ ├── header_deprecated.hpp │ ├── helper_macros.hpp │ ├── no_tr1 │ │ ├── cmath.hpp │ │ ├── complex.hpp │ │ ├── functional.hpp │ │ ├── memory.hpp │ │ └── utility.hpp │ ├── platform │ │ ├── aix.hpp │ │ ├── amigaos.hpp │ │ ├── beos.hpp │ │ ├── bsd.hpp │ │ ├── cloudabi.hpp │ │ ├── cray.hpp │ │ ├── cygwin.hpp │ │ ├── haiku.hpp │ │ ├── hpux.hpp │ │ ├── irix.hpp │ │ ├── linux.hpp │ │ ├── macos.hpp │ │ ├── qnxnto.hpp │ │ ├── solaris.hpp │ │ ├── symbian.hpp │ │ ├── vms.hpp │ │ ├── vxworks.hpp │ │ ├── wasm.hpp │ │ ├── win32.hpp │ │ └── zos.hpp │ ├── pragma_message.hpp │ ├── requires_threads.hpp │ ├── stdlib │ │ ├── dinkumware.hpp │ │ ├── libcomo.hpp │ │ ├── libcpp.hpp │ │ ├── libstdcpp3.hpp │ │ ├── modena.hpp │ │ ├── msl.hpp │ │ ├── roguewave.hpp │ │ ├── sgi.hpp │ │ ├── stlport.hpp │ │ ├── vacpp.hpp │ │ └── xlcpp_zos.hpp │ ├── user.hpp │ ├── warning_disable.hpp │ └── workaround.hpp │ ├── container │ ├── allocator_traits.hpp │ ├── container_fwd.hpp │ ├── detail │ │ ├── addressof.hpp │ │ ├── advanced_insert_int.hpp │ │ ├── algorithm.hpp │ │ ├── alloc_helpers.hpp │ │ ├── allocation_type.hpp │ │ ├── allocator_version_traits.hpp │ │ ├── config_begin.hpp │ │ ├── config_end.hpp │ │ ├── construct_in_place.hpp │ │ ├── copy_move_algo.hpp │ │ ├── destroyers.hpp │ │ ├── iterator.hpp │ │ ├── iterators.hpp │ │ ├── min_max.hpp │ │ ├── mpl.hpp │ │ ├── multiallocation_chain.hpp │ │ ├── next_capacity.hpp │ │ ├── placement_new.hpp │ │ ├── std_fwd.hpp │ │ ├── transform_iterator.hpp │ │ ├── type_traits.hpp │ │ ├── value_functors.hpp │ │ ├── value_init.hpp │ │ ├── variadic_templates_tools.hpp │ │ ├── version_type.hpp │ │ └── workaround.hpp │ ├── new_allocator.hpp │ ├── options.hpp │ ├── stable_vector.hpp │ ├── throw_exception.hpp │ └── vector.hpp │ ├── core │ ├── addressof.hpp │ ├── checked_delete.hpp │ ├── cmath.hpp │ ├── demangle.hpp │ ├── enable_if.hpp │ ├── ignore_unused.hpp │ ├── is_same.hpp │ ├── no_exceptions_support.hpp │ ├── noncopyable.hpp │ ├── ref.hpp │ ├── snprintf.hpp │ ├── swap.hpp │ ├── typeinfo.hpp │ └── use_default.hpp │ ├── cstdint.hpp │ ├── current_function.hpp │ ├── detail │ ├── basic_pointerbuf.hpp │ ├── call_traits.hpp │ ├── compressed_pair.hpp │ ├── indirect_traits.hpp │ ├── is_incrementable.hpp │ ├── lcast_precision.hpp │ ├── select_type.hpp │ └── workaround.hpp │ ├── exception │ └── exception.hpp │ ├── get_pointer.hpp │ ├── integer.hpp │ ├── integer_fwd.hpp │ ├── integer_traits.hpp │ ├── intrusive │ ├── circular_slist_algorithms.hpp │ ├── detail │ │ ├── algo_type.hpp │ │ ├── algorithm.hpp │ │ ├── array_initializer.hpp │ │ ├── assert.hpp │ │ ├── common_slist_algorithms.hpp │ │ ├── config_begin.hpp │ │ ├── config_end.hpp │ │ ├── default_header_holder.hpp │ │ ├── ebo_functor_holder.hpp │ │ ├── equal_to_value.hpp │ │ ├── exception_disposer.hpp │ │ ├── function_detector.hpp │ │ ├── generic_hook.hpp │ │ ├── get_value_traits.hpp │ │ ├── has_member_function_callable_with.hpp │ │ ├── hook_traits.hpp │ │ ├── iiterator.hpp │ │ ├── is_stateful_value_traits.hpp │ │ ├── iterator.hpp │ │ ├── key_nodeptr_comp.hpp │ │ ├── minimal_pair_header.hpp │ │ ├── mpl.hpp │ │ ├── node_cloner_disposer.hpp │ │ ├── node_holder.hpp │ │ ├── parent_from_member.hpp │ │ ├── reverse_iterator.hpp │ │ ├── simple_disposers.hpp │ │ ├── size_holder.hpp │ │ ├── slist_iterator.hpp │ │ ├── slist_node.hpp │ │ ├── std_fwd.hpp │ │ ├── tree_value_compare.hpp │ │ ├── twin.hpp │ │ ├── uncast.hpp │ │ ├── value_functors.hpp │ │ └── workaround.hpp │ ├── intrusive_fwd.hpp │ ├── linear_slist_algorithms.hpp │ ├── link_mode.hpp │ ├── options.hpp │ ├── pack_options.hpp │ ├── pointer_rebind.hpp │ ├── pointer_traits.hpp │ ├── slist.hpp │ └── slist_hook.hpp │ ├── is_placeholder.hpp │ ├── iterator │ ├── advance.hpp │ ├── detail │ │ ├── config_def.hpp │ │ ├── config_undef.hpp │ │ ├── enable_if.hpp │ │ └── facade_iterator_category.hpp │ ├── distance.hpp │ ├── interoperable.hpp │ ├── iterator_adaptor.hpp │ ├── iterator_categories.hpp │ ├── iterator_concepts.hpp │ ├── iterator_facade.hpp │ ├── iterator_traits.hpp │ └── reverse_iterator.hpp │ ├── lexical_cast.hpp │ ├── lexical_cast │ ├── bad_lexical_cast.hpp │ ├── detail │ │ ├── converter_lexical.hpp │ │ ├── converter_lexical_streams.hpp │ │ ├── converter_numeric.hpp │ │ ├── inf_nan.hpp │ │ ├── is_character.hpp │ │ ├── lcast_char_constants.hpp │ │ ├── lcast_unsigned_converters.hpp │ │ └── widest_char.hpp │ └── try_lexical_convert.hpp │ ├── limits.hpp │ ├── move │ ├── adl_move_swap.hpp │ ├── algo │ │ ├── adaptive_merge.hpp │ │ ├── detail │ │ │ ├── adaptive_sort_merge.hpp │ │ │ ├── basic_op.hpp │ │ │ ├── heap_sort.hpp │ │ │ ├── insertion_sort.hpp │ │ │ ├── is_sorted.hpp │ │ │ ├── merge.hpp │ │ │ ├── merge_sort.hpp │ │ │ ├── search.hpp │ │ │ └── set_difference.hpp │ │ ├── move.hpp │ │ ├── predicate.hpp │ │ └── unique.hpp │ ├── core.hpp │ ├── detail │ │ ├── addressof.hpp │ │ ├── config_begin.hpp │ │ ├── config_end.hpp │ │ ├── destruct_n.hpp │ │ ├── force_ptr.hpp │ │ ├── fwd_macros.hpp │ │ ├── iterator_to_raw_pointer.hpp │ │ ├── iterator_traits.hpp │ │ ├── meta_utils.hpp │ │ ├── meta_utils_core.hpp │ │ ├── move_helpers.hpp │ │ ├── placement_new.hpp │ │ ├── pointer_element.hpp │ │ ├── reverse_iterator.hpp │ │ ├── std_ns_begin.hpp │ │ ├── std_ns_end.hpp │ │ ├── to_raw_pointer.hpp │ │ ├── type_traits.hpp │ │ └── workaround.hpp │ ├── iterator.hpp │ ├── traits.hpp │ └── utility_core.hpp │ ├── mpl │ ├── always.hpp │ ├── and.hpp │ ├── apply.hpp │ ├── apply_fwd.hpp │ ├── apply_wrap.hpp │ ├── arg.hpp │ ├── arg_fwd.hpp │ ├── assert.hpp │ ├── aux_ │ │ ├── adl_barrier.hpp │ │ ├── arg_typedef.hpp │ │ ├── arithmetic_op.hpp │ │ ├── arity.hpp │ │ ├── arity_spec.hpp │ │ ├── common_name_wknd.hpp │ │ ├── comparison_op.hpp │ │ ├── config │ │ │ ├── adl.hpp │ │ │ ├── arrays.hpp │ │ │ ├── bcc.hpp │ │ │ ├── bind.hpp │ │ │ ├── compiler.hpp │ │ │ ├── ctps.hpp │ │ │ ├── dmc_ambiguous_ctps.hpp │ │ │ ├── dtp.hpp │ │ │ ├── eti.hpp │ │ │ ├── forwarding.hpp │ │ │ ├── gcc.hpp │ │ │ ├── gpu.hpp │ │ │ ├── has_apply.hpp │ │ │ ├── has_xxx.hpp │ │ │ ├── integral.hpp │ │ │ ├── intel.hpp │ │ │ ├── lambda.hpp │ │ │ ├── msvc.hpp │ │ │ ├── msvc_typename.hpp │ │ │ ├── nttp.hpp │ │ │ ├── overload_resolution.hpp │ │ │ ├── pp_counter.hpp │ │ │ ├── preprocessor.hpp │ │ │ ├── static_constant.hpp │ │ │ ├── ttp.hpp │ │ │ ├── use_preprocessed.hpp │ │ │ └── workaround.hpp │ │ ├── count_args.hpp │ │ ├── full_lambda.hpp │ │ ├── has_apply.hpp │ │ ├── has_rebind.hpp │ │ ├── has_tag.hpp │ │ ├── has_type.hpp │ │ ├── include_preprocessed.hpp │ │ ├── integral_wrapper.hpp │ │ ├── is_msvc_eti_arg.hpp │ │ ├── lambda_arity_param.hpp │ │ ├── lambda_no_ctps.hpp │ │ ├── lambda_support.hpp │ │ ├── largest_int.hpp │ │ ├── logical_op.hpp │ │ ├── msvc_dtw.hpp │ │ ├── msvc_eti_base.hpp │ │ ├── msvc_is_class.hpp │ │ ├── msvc_never_true.hpp │ │ ├── na.hpp │ │ ├── na_assert.hpp │ │ ├── na_fwd.hpp │ │ ├── na_spec.hpp │ │ ├── nested_type_wknd.hpp │ │ ├── nttp_decl.hpp │ │ ├── numeric_cast_utils.hpp │ │ ├── numeric_op.hpp │ │ ├── preprocessed │ │ │ ├── bcc │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── bcc551 │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── bcc_pre590 │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── dmc │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── gcc │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── msvc60 │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── msvc70 │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── mwcw │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── no_ctps │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ ├── no_ttp │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ │ └── plain │ │ │ │ ├── advance_backward.hpp │ │ │ │ ├── advance_forward.hpp │ │ │ │ ├── and.hpp │ │ │ │ ├── apply.hpp │ │ │ │ ├── apply_fwd.hpp │ │ │ │ ├── apply_wrap.hpp │ │ │ │ ├── arg.hpp │ │ │ │ ├── basic_bind.hpp │ │ │ │ ├── bind.hpp │ │ │ │ ├── bind_fwd.hpp │ │ │ │ ├── bitand.hpp │ │ │ │ ├── bitor.hpp │ │ │ │ ├── bitxor.hpp │ │ │ │ ├── deque.hpp │ │ │ │ ├── divides.hpp │ │ │ │ ├── equal_to.hpp │ │ │ │ ├── fold_impl.hpp │ │ │ │ ├── full_lambda.hpp │ │ │ │ ├── greater.hpp │ │ │ │ ├── greater_equal.hpp │ │ │ │ ├── inherit.hpp │ │ │ │ ├── iter_fold_if_impl.hpp │ │ │ │ ├── iter_fold_impl.hpp │ │ │ │ ├── lambda_no_ctps.hpp │ │ │ │ ├── less.hpp │ │ │ │ ├── less_equal.hpp │ │ │ │ ├── list.hpp │ │ │ │ ├── list_c.hpp │ │ │ │ ├── map.hpp │ │ │ │ ├── minus.hpp │ │ │ │ ├── modulus.hpp │ │ │ │ ├── not_equal_to.hpp │ │ │ │ ├── or.hpp │ │ │ │ ├── placeholders.hpp │ │ │ │ ├── plus.hpp │ │ │ │ ├── quote.hpp │ │ │ │ ├── reverse_fold_impl.hpp │ │ │ │ ├── reverse_iter_fold_impl.hpp │ │ │ │ ├── set.hpp │ │ │ │ ├── set_c.hpp │ │ │ │ ├── shift_left.hpp │ │ │ │ ├── shift_right.hpp │ │ │ │ ├── template_arity.hpp │ │ │ │ ├── times.hpp │ │ │ │ ├── unpack_args.hpp │ │ │ │ ├── vector.hpp │ │ │ │ └── vector_c.hpp │ │ ├── preprocessor │ │ │ ├── add.hpp │ │ │ ├── def_params_tail.hpp │ │ │ ├── default_params.hpp │ │ │ ├── enum.hpp │ │ │ ├── ext_params.hpp │ │ │ ├── filter_params.hpp │ │ │ ├── params.hpp │ │ │ ├── partial_spec_params.hpp │ │ │ ├── range.hpp │ │ │ ├── repeat.hpp │ │ │ ├── sub.hpp │ │ │ └── tuple.hpp │ │ ├── static_cast.hpp │ │ ├── template_arity.hpp │ │ ├── template_arity_fwd.hpp │ │ ├── type_wrapper.hpp │ │ ├── value_wknd.hpp │ │ └── yes_no.hpp │ ├── bind.hpp │ ├── bind_fwd.hpp │ ├── bool.hpp │ ├── bool_fwd.hpp │ ├── equal_to.hpp │ ├── eval_if.hpp │ ├── has_xxx.hpp │ ├── identity.hpp │ ├── if.hpp │ ├── int.hpp │ ├── int_fwd.hpp │ ├── integral_c.hpp │ ├── integral_c_fwd.hpp │ ├── integral_c_tag.hpp │ ├── is_placeholder.hpp │ ├── lambda.hpp │ ├── lambda_fwd.hpp │ ├── less.hpp │ ├── limits │ │ └── arity.hpp │ ├── multiplies.hpp │ ├── next.hpp │ ├── next_prior.hpp │ ├── not.hpp │ ├── numeric_cast.hpp │ ├── or.hpp │ ├── placeholders.hpp │ ├── protect.hpp │ ├── quote.hpp │ ├── tag.hpp │ ├── times.hpp │ ├── void.hpp │ └── void_fwd.hpp │ ├── next_prior.hpp │ ├── noncopyable.hpp │ ├── numeric │ └── conversion │ │ ├── bounds.hpp │ │ ├── cast.hpp │ │ ├── conversion_traits.hpp │ │ ├── converter.hpp │ │ ├── converter_policies.hpp │ │ ├── detail │ │ ├── bounds.hpp │ │ ├── conversion_traits.hpp │ │ ├── converter.hpp │ │ ├── int_float_mixture.hpp │ │ ├── is_subranged.hpp │ │ ├── meta.hpp │ │ ├── numeric_cast_traits.hpp │ │ ├── old_numeric_cast.hpp │ │ ├── preprocessed │ │ │ ├── numeric_cast_traits_common.hpp │ │ │ └── numeric_cast_traits_long_long.hpp │ │ ├── sign_mixture.hpp │ │ └── udt_builtin_mixture.hpp │ │ ├── int_float_mixture_enum.hpp │ │ ├── numeric_cast_traits.hpp │ │ ├── sign_mixture_enum.hpp │ │ └── udt_builtin_mixture_enum.hpp │ ├── pointee.hpp │ ├── preprocessor │ ├── arithmetic │ │ ├── add.hpp │ │ ├── dec.hpp │ │ ├── detail │ │ │ ├── div_base.hpp │ │ │ ├── is_1_number.hpp │ │ │ ├── is_maximum_number.hpp │ │ │ ├── is_minimum_number.hpp │ │ │ └── maximum_number.hpp │ │ ├── inc.hpp │ │ ├── limits │ │ │ ├── dec_1024.hpp │ │ │ ├── dec_256.hpp │ │ │ ├── dec_512.hpp │ │ │ ├── inc_1024.hpp │ │ │ ├── inc_256.hpp │ │ │ └── inc_512.hpp │ │ ├── mod.hpp │ │ └── sub.hpp │ ├── array │ │ ├── data.hpp │ │ ├── elem.hpp │ │ └── size.hpp │ ├── cat.hpp │ ├── comma_if.hpp │ ├── comparison │ │ ├── equal.hpp │ │ ├── less_equal.hpp │ │ ├── limits │ │ │ ├── not_equal_1024.hpp │ │ │ ├── not_equal_256.hpp │ │ │ └── not_equal_512.hpp │ │ └── not_equal.hpp │ ├── config │ │ ├── config.hpp │ │ └── limits.hpp │ ├── control │ │ ├── deduce_d.hpp │ │ ├── detail │ │ │ ├── dmc │ │ │ │ └── while.hpp │ │ │ ├── edg │ │ │ │ ├── limits │ │ │ │ │ ├── while_1024.hpp │ │ │ │ │ ├── while_256.hpp │ │ │ │ │ └── while_512.hpp │ │ │ │ └── while.hpp │ │ │ ├── limits │ │ │ │ ├── while_1024.hpp │ │ │ │ ├── while_256.hpp │ │ │ │ └── while_512.hpp │ │ │ ├── msvc │ │ │ │ └── while.hpp │ │ │ └── while.hpp │ │ ├── expr_if.hpp │ │ ├── expr_iif.hpp │ │ ├── if.hpp │ │ ├── iif.hpp │ │ ├── limits │ │ │ ├── while_1024.hpp │ │ │ ├── while_256.hpp │ │ │ └── while_512.hpp │ │ └── while.hpp │ ├── debug │ │ └── error.hpp │ ├── dec.hpp │ ├── detail │ │ ├── auto_rec.hpp │ │ ├── check.hpp │ │ ├── dmc │ │ │ └── auto_rec.hpp │ │ ├── is_binary.hpp │ │ └── limits │ │ │ ├── auto_rec_1024.hpp │ │ │ ├── auto_rec_256.hpp │ │ │ └── auto_rec_512.hpp │ ├── empty.hpp │ ├── enum_shifted_params.hpp │ ├── expr_if.hpp │ ├── facilities │ │ ├── check_empty.hpp │ │ ├── detail │ │ │ └── is_empty.hpp │ │ ├── empty.hpp │ │ ├── expand.hpp │ │ ├── identity.hpp │ │ ├── intercept.hpp │ │ ├── is_1.hpp │ │ ├── is_empty.hpp │ │ ├── is_empty_variadic.hpp │ │ ├── limits │ │ │ ├── intercept_1024.hpp │ │ │ ├── intercept_256.hpp │ │ │ └── intercept_512.hpp │ │ └── overload.hpp │ ├── identity.hpp │ ├── inc.hpp │ ├── iterate.hpp │ ├── iteration │ │ ├── detail │ │ │ ├── bounds │ │ │ │ ├── lower1.hpp │ │ │ │ ├── lower2.hpp │ │ │ │ ├── lower3.hpp │ │ │ │ ├── lower4.hpp │ │ │ │ ├── lower5.hpp │ │ │ │ ├── upper1.hpp │ │ │ │ ├── upper2.hpp │ │ │ │ ├── upper3.hpp │ │ │ │ ├── upper4.hpp │ │ │ │ └── upper5.hpp │ │ │ ├── finish.hpp │ │ │ ├── iter │ │ │ │ ├── forward1.hpp │ │ │ │ ├── forward2.hpp │ │ │ │ ├── forward3.hpp │ │ │ │ ├── forward4.hpp │ │ │ │ ├── forward5.hpp │ │ │ │ ├── limits │ │ │ │ │ ├── forward1_1024.hpp │ │ │ │ │ ├── forward1_256.hpp │ │ │ │ │ ├── forward1_512.hpp │ │ │ │ │ ├── forward2_1024.hpp │ │ │ │ │ ├── forward2_256.hpp │ │ │ │ │ ├── forward2_512.hpp │ │ │ │ │ ├── forward3_1024.hpp │ │ │ │ │ ├── forward3_256.hpp │ │ │ │ │ ├── forward3_512.hpp │ │ │ │ │ ├── forward4_1024.hpp │ │ │ │ │ ├── forward4_256.hpp │ │ │ │ │ ├── forward4_512.hpp │ │ │ │ │ ├── forward5_1024.hpp │ │ │ │ │ ├── forward5_256.hpp │ │ │ │ │ ├── forward5_512.hpp │ │ │ │ │ ├── reverse1_1024.hpp │ │ │ │ │ ├── reverse1_256.hpp │ │ │ │ │ ├── reverse1_512.hpp │ │ │ │ │ ├── reverse2_1024.hpp │ │ │ │ │ ├── reverse2_256.hpp │ │ │ │ │ ├── reverse2_512.hpp │ │ │ │ │ ├── reverse3_1024.hpp │ │ │ │ │ ├── reverse3_256.hpp │ │ │ │ │ ├── reverse3_512.hpp │ │ │ │ │ ├── reverse4_1024.hpp │ │ │ │ │ ├── reverse4_256.hpp │ │ │ │ │ ├── reverse4_512.hpp │ │ │ │ │ ├── reverse5_1024.hpp │ │ │ │ │ ├── reverse5_256.hpp │ │ │ │ │ └── reverse5_512.hpp │ │ │ │ ├── reverse1.hpp │ │ │ │ ├── reverse2.hpp │ │ │ │ ├── reverse3.hpp │ │ │ │ ├── reverse4.hpp │ │ │ │ └── reverse5.hpp │ │ │ ├── limits │ │ │ │ ├── local_1024.hpp │ │ │ │ ├── local_256.hpp │ │ │ │ ├── local_512.hpp │ │ │ │ ├── rlocal_1024.hpp │ │ │ │ ├── rlocal_256.hpp │ │ │ │ └── rlocal_512.hpp │ │ │ ├── local.hpp │ │ │ ├── rlocal.hpp │ │ │ ├── self.hpp │ │ │ └── start.hpp │ │ ├── iterate.hpp │ │ ├── local.hpp │ │ └── self.hpp │ ├── list │ │ ├── adt.hpp │ │ ├── detail │ │ │ ├── dmc │ │ │ │ └── fold_left.hpp │ │ │ ├── edg │ │ │ │ ├── fold_left.hpp │ │ │ │ ├── fold_right.hpp │ │ │ │ └── limits │ │ │ │ │ ├── fold_left_1024.hpp │ │ │ │ │ ├── fold_left_256.hpp │ │ │ │ │ ├── fold_left_512.hpp │ │ │ │ │ ├── fold_right_1024.hpp │ │ │ │ │ ├── fold_right_256.hpp │ │ │ │ │ └── fold_right_512.hpp │ │ │ ├── fold_left.hpp │ │ │ ├── fold_right.hpp │ │ │ └── limits │ │ │ │ ├── fold_left_1024.hpp │ │ │ │ ├── fold_left_256.hpp │ │ │ │ ├── fold_left_512.hpp │ │ │ │ ├── fold_right_1024.hpp │ │ │ │ ├── fold_right_256.hpp │ │ │ │ └── fold_right_512.hpp │ │ ├── fold_left.hpp │ │ ├── fold_right.hpp │ │ ├── for_each_i.hpp │ │ ├── limits │ │ │ ├── fold_left_1024.hpp │ │ │ ├── fold_left_256.hpp │ │ │ └── fold_left_512.hpp │ │ └── reverse.hpp │ ├── logical │ │ ├── and.hpp │ │ ├── bitand.hpp │ │ ├── bitor.hpp │ │ ├── bool.hpp │ │ ├── compl.hpp │ │ ├── limits │ │ │ ├── bool_1024.hpp │ │ │ ├── bool_256.hpp │ │ │ └── bool_512.hpp │ │ └── not.hpp │ ├── punctuation │ │ ├── comma.hpp │ │ ├── comma_if.hpp │ │ ├── detail │ │ │ └── is_begin_parens.hpp │ │ └── is_begin_parens.hpp │ ├── repeat.hpp │ ├── repetition │ │ ├── detail │ │ │ ├── dmc │ │ │ │ └── for.hpp │ │ │ ├── edg │ │ │ │ ├── for.hpp │ │ │ │ └── limits │ │ │ │ │ ├── for_1024.hpp │ │ │ │ │ ├── for_256.hpp │ │ │ │ │ └── for_512.hpp │ │ │ ├── for.hpp │ │ │ ├── limits │ │ │ │ ├── for_1024.hpp │ │ │ │ ├── for_256.hpp │ │ │ │ └── for_512.hpp │ │ │ └── msvc │ │ │ │ └── for.hpp │ │ ├── enum_binary_params.hpp │ │ ├── enum_params.hpp │ │ ├── enum_shifted_params.hpp │ │ ├── enum_trailing_params.hpp │ │ ├── for.hpp │ │ ├── limits │ │ │ ├── for_1024.hpp │ │ │ ├── for_256.hpp │ │ │ ├── for_512.hpp │ │ │ ├── repeat_1024.hpp │ │ │ ├── repeat_256.hpp │ │ │ └── repeat_512.hpp │ │ ├── repeat.hpp │ │ └── repeat_from_to.hpp │ ├── seq │ │ ├── cat.hpp │ │ ├── detail │ │ │ ├── is_empty.hpp │ │ │ ├── limits │ │ │ │ ├── split_1024.hpp │ │ │ │ ├── split_256.hpp │ │ │ │ └── split_512.hpp │ │ │ └── split.hpp │ │ ├── elem.hpp │ │ ├── enum.hpp │ │ ├── first_n.hpp │ │ ├── fold_left.hpp │ │ ├── for_each_i.hpp │ │ ├── limits │ │ │ ├── elem_1024.hpp │ │ │ ├── elem_256.hpp │ │ │ ├── elem_512.hpp │ │ │ ├── enum_1024.hpp │ │ │ ├── enum_256.hpp │ │ │ ├── enum_512.hpp │ │ │ ├── fold_left_1024.hpp │ │ │ ├── fold_left_256.hpp │ │ │ ├── fold_left_512.hpp │ │ │ ├── size_1024.hpp │ │ │ ├── size_256.hpp │ │ │ └── size_512.hpp │ │ ├── rest_n.hpp │ │ ├── seq.hpp │ │ ├── size.hpp │ │ ├── subseq.hpp │ │ └── transform.hpp │ ├── slot │ │ ├── detail │ │ │ ├── counter.hpp │ │ │ ├── def.hpp │ │ │ ├── shared.hpp │ │ │ ├── slot1.hpp │ │ │ ├── slot2.hpp │ │ │ ├── slot3.hpp │ │ │ ├── slot4.hpp │ │ │ └── slot5.hpp │ │ └── slot.hpp │ ├── stringize.hpp │ ├── tuple │ │ ├── detail │ │ │ └── is_single_return.hpp │ │ ├── eat.hpp │ │ ├── elem.hpp │ │ ├── limits │ │ │ ├── to_list_128.hpp │ │ │ ├── to_list_256.hpp │ │ │ └── to_list_64.hpp │ │ ├── rem.hpp │ │ ├── size.hpp │ │ └── to_list.hpp │ └── variadic │ │ ├── detail │ │ └── has_opt.hpp │ │ ├── elem.hpp │ │ ├── has_opt.hpp │ │ ├── limits │ │ ├── elem_128.hpp │ │ ├── elem_256.hpp │ │ ├── elem_64.hpp │ │ ├── size_128.hpp │ │ ├── size_256.hpp │ │ └── size_64.hpp │ │ └── size.hpp │ ├── ptr_container │ ├── clone_allocator.hpp │ ├── detail │ │ ├── default_deleter.hpp │ │ ├── is_convertible.hpp │ │ ├── move.hpp │ │ ├── ptr_container_disable_deprecated.hpp │ │ ├── reversible_ptr_container.hpp │ │ ├── scoped_deleter.hpp │ │ ├── static_move_ptr.hpp │ │ ├── throw_exception.hpp │ │ └── void_ptr_iterator.hpp │ ├── exception.hpp │ ├── indirect_fun.hpp │ ├── nullable.hpp │ ├── ptr_sequence_adapter.hpp │ └── ptr_vector.hpp │ ├── range │ ├── algorithm │ │ └── equal.hpp │ ├── algorithm_ext │ │ └── for_each.hpp │ ├── begin.hpp │ ├── concepts.hpp │ ├── config.hpp │ ├── const_iterator.hpp │ ├── detail │ │ ├── common.hpp │ │ ├── extract_optional_type.hpp │ │ ├── has_member_size.hpp │ │ ├── implementation_help.hpp │ │ ├── misc_concept.hpp │ │ ├── msvc_has_iterator_workaround.hpp │ │ ├── safe_bool.hpp │ │ └── sfinae.hpp │ ├── difference_type.hpp │ ├── distance.hpp │ ├── empty.hpp │ ├── end.hpp │ ├── functions.hpp │ ├── has_range_iterator.hpp │ ├── iterator.hpp │ ├── iterator_range_core.hpp │ ├── mutable_iterator.hpp │ ├── range_fwd.hpp │ ├── rbegin.hpp │ ├── rend.hpp │ ├── reverse_iterator.hpp │ ├── size.hpp │ ├── size_type.hpp │ └── value_type.hpp │ ├── ref.hpp │ ├── scoped_array.hpp │ ├── scoped_ptr.hpp │ ├── shared_ptr.hpp │ ├── smart_ptr │ ├── bad_weak_ptr.hpp │ ├── detail │ │ ├── lightweight_mutex.hpp │ │ ├── local_counted_base.hpp │ │ ├── local_sp_deleter.hpp │ │ ├── lwm_pthreads.hpp │ │ ├── lwm_std_mutex.hpp │ │ ├── lwm_win32_cs.hpp │ │ ├── operator_bool.hpp │ │ ├── quick_allocator.hpp │ │ ├── shared_count.hpp │ │ ├── sp_convertible.hpp │ │ ├── sp_counted_base.hpp │ │ ├── sp_counted_base_acc_ia64.hpp │ │ ├── sp_counted_base_aix.hpp │ │ ├── sp_counted_base_cw_ppc.hpp │ │ ├── sp_counted_base_gcc_atomic.hpp │ │ ├── sp_counted_base_gcc_ia64.hpp │ │ ├── sp_counted_base_gcc_mips.hpp │ │ ├── sp_counted_base_gcc_ppc.hpp │ │ ├── sp_counted_base_gcc_sparc.hpp │ │ ├── sp_counted_base_gcc_x86.hpp │ │ ├── sp_counted_base_nt.hpp │ │ ├── sp_counted_base_pt.hpp │ │ ├── sp_counted_base_snc_ps3.hpp │ │ ├── sp_counted_base_spin.hpp │ │ ├── sp_counted_base_std_atomic.hpp │ │ ├── sp_counted_base_sync.hpp │ │ ├── sp_counted_base_vacpp_ppc.hpp │ │ ├── sp_counted_base_w32.hpp │ │ ├── sp_counted_impl.hpp │ │ ├── sp_disable_deprecated.hpp │ │ ├── sp_has_gcc_intrinsics.hpp │ │ ├── sp_has_sync_intrinsics.hpp │ │ ├── sp_interlocked.hpp │ │ ├── sp_noexcept.hpp │ │ ├── sp_nullptr_t.hpp │ │ ├── sp_obsolete.hpp │ │ ├── sp_thread_pause.hpp │ │ ├── sp_thread_sleep.hpp │ │ ├── sp_thread_yield.hpp │ │ ├── sp_typeinfo_.hpp │ │ ├── sp_win32_sleep.hpp │ │ ├── spinlock.hpp │ │ ├── spinlock_gcc_arm.hpp │ │ ├── spinlock_gcc_atomic.hpp │ │ ├── spinlock_nt.hpp │ │ ├── spinlock_pool.hpp │ │ ├── spinlock_pt.hpp │ │ ├── spinlock_std_atomic.hpp │ │ ├── spinlock_sync.hpp │ │ ├── spinlock_w32.hpp │ │ └── yield_k.hpp │ ├── scoped_array.hpp │ ├── scoped_ptr.hpp │ └── shared_ptr.hpp │ ├── static_assert.hpp │ ├── swap.hpp │ ├── throw_exception.hpp │ ├── type.hpp │ ├── type_traits │ ├── add_const.hpp │ ├── add_lvalue_reference.hpp │ ├── add_pointer.hpp │ ├── add_reference.hpp │ ├── add_rvalue_reference.hpp │ ├── add_volatile.hpp │ ├── alignment_of.hpp │ ├── conditional.hpp │ ├── conversion_traits.hpp │ ├── declval.hpp │ ├── detail │ │ ├── bool_trait_undef.hpp │ │ ├── config.hpp │ │ ├── has_binary_operator.hpp │ │ ├── is_function_cxx_03.hpp │ │ ├── is_function_cxx_11.hpp │ │ ├── is_function_msvc10_fix.hpp │ │ ├── is_function_ptr_helper.hpp │ │ ├── is_function_ptr_tester.hpp │ │ ├── is_likely_lambda.hpp │ │ ├── is_mem_fun_pointer_impl.hpp │ │ ├── is_mem_fun_pointer_tester.hpp │ │ ├── is_member_function_pointer_cxx_03.hpp │ │ ├── is_member_function_pointer_cxx_11.hpp │ │ ├── is_rvalue_reference_msvc10_fix.hpp │ │ └── yes_no_type.hpp │ ├── enable_if.hpp │ ├── function_traits.hpp │ ├── has_left_shift.hpp │ ├── has_minus.hpp │ ├── has_minus_assign.hpp │ ├── has_plus.hpp │ ├── has_plus_assign.hpp │ ├── has_right_shift.hpp │ ├── integral_constant.hpp │ ├── intrinsics.hpp │ ├── is_abstract.hpp │ ├── is_arithmetic.hpp │ ├── is_array.hpp │ ├── is_base_and_derived.hpp │ ├── is_base_of.hpp │ ├── is_class.hpp │ ├── is_complete.hpp │ ├── is_const.hpp │ ├── is_convertible.hpp │ ├── is_empty.hpp │ ├── is_enum.hpp │ ├── is_final.hpp │ ├── is_float.hpp │ ├── is_floating_point.hpp │ ├── is_function.hpp │ ├── is_fundamental.hpp │ ├── is_integral.hpp │ ├── is_lvalue_reference.hpp │ ├── is_member_function_pointer.hpp │ ├── is_member_pointer.hpp │ ├── is_pod.hpp │ ├── is_pointer.hpp │ ├── is_polymorphic.hpp │ ├── is_reference.hpp │ ├── is_rvalue_reference.hpp │ ├── is_same.hpp │ ├── is_scalar.hpp │ ├── is_signed.hpp │ ├── is_union.hpp │ ├── is_unsigned.hpp │ ├── is_void.hpp │ ├── is_volatile.hpp │ ├── make_unsigned.hpp │ ├── make_void.hpp │ ├── remove_bounds.hpp │ ├── remove_const.hpp │ ├── remove_cv.hpp │ ├── remove_extent.hpp │ ├── remove_pointer.hpp │ ├── remove_reference.hpp │ ├── remove_volatile.hpp │ ├── type_identity.hpp │ └── type_with_alignment.hpp │ ├── utility.hpp │ ├── utility │ ├── base_from_member.hpp │ ├── binary.hpp │ ├── detail │ │ ├── result_of_iterate.hpp │ │ └── result_of_variadic.hpp │ ├── enable_if.hpp │ ├── identity_type.hpp │ └── result_of.hpp │ ├── version.hpp │ └── visit_each.hpp ├── tests ├── testthat.R └── testthat │ ├── data │ └── large_object.txt │ ├── helper-DBItest.R │ ├── helper-astyle.R │ ├── helper-with_database_connection.R │ ├── helper-with_table.R │ ├── helper-without_rownames.R │ ├── test-DBItest.R │ ├── test-ImportLargeObject.R │ ├── test-Redshift.R │ ├── test-bigint.R │ ├── test-checkInterrupts.R │ ├── test-data-type.R │ ├── test-dbConnect.R │ ├── test-dbGetQuery.R │ ├── test-dbQuoteIdentifier.R │ ├── test-dbQuoteLiteral.R │ ├── test-dbWriteTable.R │ ├── test-encoding.R │ ├── test-immediate.R │ ├── test-isTransacting.R │ ├── test-timezone.R │ ├── test-transactions.R │ ├── test-types.R │ └── test-waitForNotify.R ├── tools └── winlibs.R ├── vignettes └── work-queue.Rmd └── vscode-install.r /.Rbuildignore: -------------------------------------------------------------------------------- 1 | ^\.github$ 2 | ^.*\.Rproj$ 3 | ^\.Rproj\.user$ 4 | ^\.travis\.yml$ 5 | ^src/Makevars$ 6 | ^clion-test\.R$ 7 | ^cran-comments\.md$ 8 | ^src/.*\.d$ 9 | ^src/.*\.gch$ 10 | ^appveyor\.yml$ 11 | ^tic\.R$ 12 | ^_pkgdown\.yml$ 13 | ^docs$ 14 | ^CRAN-RELEASE$ 15 | ^codecov\.yml$ 16 | ^LICENSE\.md$ 17 | ^CODE_OF_CONDUCT\.md$ 18 | ^tests/testthat/testthat-problems\.rds$ 19 | ^.*\.log$ 20 | ^\.vscode$ 21 | ^\.deps$ 22 | ^autobrew$ 23 | ^cleanup$ 24 | ^CRAN-SUBMISSION$ 25 | ^\.gitpod\.yml$ 26 | ^\.gitpod\.Dockerfile$ 27 | ^CMakeLists\.txt$ 28 | ^vscode-install\.r$ 29 | ^vscode-.*build$ 30 | ^windows$ 31 | ^Dockerfile$ 32 | ^docker-compose\.yml$ 33 | -------------------------------------------------------------------------------- /.aspell/DBI.rds: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r-dbi/RPostgres/3386d7abdb7d245f23a10f801062575e63e25c55/.aspell/DBI.rds -------------------------------------------------------------------------------- /.aspell/defaults.R: -------------------------------------------------------------------------------- 1 | Rd_files <- vignettes <- R_files <- description <- 2 | list(encoding = "UTF-8", 3 | language = "en", 4 | dictionaries = c("en_stats", "DBI")) 5 | -------------------------------------------------------------------------------- /.github/.gitignore: -------------------------------------------------------------------------------- 1 | *.html 2 | /pkg.lock 3 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE.md: -------------------------------------------------------------------------------- 1 | Please briefly describe your problem and what output you expect. If you have a question, please don't use this form. Instead, ask on or . 2 | 3 | Please include a minimal reproducible example (AKA a reprex). If you've never heard of a [reprex](https://reprex.tidyverse.org/) before, start by reading . 4 | 5 | --- 6 | 7 | Brief description of the problem 8 | 9 | ```r 10 | # insert reprex here 11 | ``` 12 | -------------------------------------------------------------------------------- /.github/move.yml: -------------------------------------------------------------------------------- 1 | # Configuration for move-issues bot - https://github.com/dessant/move-issues 2 | 3 | # Delete the command comment when it contains no other content 4 | deleteCommand: true 5 | 6 | # Close the source issue after moving 7 | closeSourceIssue: true 8 | 9 | # Lock the source issue after moving 10 | lockSourceIssue: false 11 | 12 | # Mention issue and comment authors 13 | mentionAuthors: true 14 | 15 | # Preserve mentions in the issue content 16 | keepContentMentions: true 17 | 18 | # Set custom aliases for targets 19 | # aliases: 20 | # r: repo 21 | # or: owner/repo 22 | -------------------------------------------------------------------------------- /.github/security.md: -------------------------------------------------------------------------------- 1 | # Process for reporting security vulnerabilities 2 | 3 | For reporting a security vulnerability, please e-mail the package maintainer at krlmlr+r@mailbox.org for further instructions. 4 | Do not include confidential information in the e-mail. 5 | -------------------------------------------------------------------------------- /.github/versions-matrix.R: -------------------------------------------------------------------------------- 1 | windows_versions <- data.frame(os = "windows-latest", r = r_versions[4:5]) 2 | rbind(windows_versions) 3 | -------------------------------------------------------------------------------- /.github/workflows/check/action.yml: -------------------------------------------------------------------------------- 1 | name: "Actions to check an R package" 2 | inputs: 3 | results: 4 | description: Slug for check results 5 | required: true 6 | 7 | runs: 8 | using: "composite" 9 | steps: 10 | - uses: r-lib/actions/check-r-package@v2 11 | with: 12 | # Fails on R 3.6 on Windows, remove when this job is removed? 13 | args: 'c("--no-manual", "--as-cran", "--no-multiarch")' 14 | error-on: ${{ env.RCMDCHECK_ERROR_ON || '"note"' }} 15 | 16 | - name: Show test output 17 | if: always() 18 | run: | 19 | ## -- Show test output -- 20 | echo "::group::Test output" 21 | find check -name '*.Rout*' -exec head -n 1000000 '{}' \; || true 22 | echo "::endgroup::" 23 | shell: bash 24 | 25 | - name: Upload check results 26 | if: failure() 27 | uses: actions/upload-artifact@main 28 | with: 29 | name: ${{ inputs.results }}-results 30 | path: check 31 | -------------------------------------------------------------------------------- /.github/workflows/custom/before-install/action.yml: -------------------------------------------------------------------------------- 1 | name: 'Custom steps to run before R packages are installed' 2 | 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Define R CMD check error condition 7 | run: | 8 | echo '_R_CHECK_PKG_SIZES_=FALSE' | tee -a $GITHUB_ENV 9 | shell: bash 10 | -------------------------------------------------------------------------------- /.github/workflows/dep-suggests-matrix/action.yml: -------------------------------------------------------------------------------- 1 | name: "Actions to compute a matrix with all suggested packages" 2 | outputs: 3 | matrix: 4 | description: "Generated matrix" 5 | value: ${{ steps.set-matrix.outputs.matrix }} 6 | 7 | runs: 8 | using: "composite" 9 | steps: 10 | - id: set-matrix 11 | run: | 12 | Rscript ./.github/workflows/dep-suggests-matrix/action.R 13 | shell: bash 14 | -------------------------------------------------------------------------------- /.github/workflows/get-extra/action.yml: -------------------------------------------------------------------------------- 1 | name: "Action to determine extra packages to be installed" 2 | outputs: 3 | packages: 4 | description: "List of extra packages" 5 | value: ${{ steps.get-extra.outputs.packages }} 6 | 7 | runs: 8 | using: "composite" 9 | steps: 10 | - name: Get extra packages 11 | id: get-extra 12 | run: | 13 | set -x 14 | packages=$( ( grep Config/gha/extra-packages DESCRIPTION || true ) | cut -d " " -f 2) 15 | echo packages=$packages >> $GITHUB_OUTPUT 16 | shell: bash 17 | -------------------------------------------------------------------------------- /.github/workflows/git-identity/action.yml: -------------------------------------------------------------------------------- 1 | name: "Actions to set up a Git identity" 2 | 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Configure Git identity 7 | run: | 8 | env | sort 9 | git config --local user.name "$GITHUB_ACTOR" 10 | git config --local user.email "$GITHUB_ACTOR@users.noreply.github.com" 11 | shell: bash 12 | -------------------------------------------------------------------------------- /.github/workflows/lock.yaml: -------------------------------------------------------------------------------- 1 | name: "Lock threads" 2 | permissions: 3 | issues: write 4 | pull-requests: write 5 | discussions: write 6 | on: 7 | workflow_dispatch: 8 | schedule: 9 | - cron: "37 2 * * *" 10 | 11 | jobs: 12 | lock: 13 | runs-on: ubuntu-24.04 14 | steps: 15 | - uses: krlmlr/lock-threads@patch-1 16 | with: 17 | github-token: ${{ github.token }} 18 | issue-inactive-days: "365" 19 | issue-lock-reason: "" 20 | issue-comment: > 21 | This old thread has been automatically locked. If you think you have 22 | found something related to this, please open a new issue and link to this 23 | old issue if necessary. 24 | -------------------------------------------------------------------------------- /.github/workflows/matrix-check/action.yml: -------------------------------------------------------------------------------- 1 | name: "Actions to check a matrix with all R and OS versions, computed with the versions-matrix action" 2 | inputs: 3 | matrix: 4 | description: "Generated matrix" 5 | required: true 6 | 7 | runs: 8 | using: "composite" 9 | steps: 10 | - name: Install json2yaml 11 | run: | 12 | sudo npm install -g json2yaml 13 | shell: bash 14 | 15 | - run: | 16 | matrix='${{ inputs.matrix }}' 17 | if [ -n "${matrix}" ]; then 18 | echo $matrix | jq . 19 | echo $matrix | json2yaml 20 | else 21 | echo "No matrix found" 22 | fi 23 | shell: bash 24 | -------------------------------------------------------------------------------- /.github/workflows/pkgdown-build/action.yml: -------------------------------------------------------------------------------- 1 | name: "Action to build a pkgdown website" 2 | 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Build site 7 | run: | 8 | pkgdown::build_site() 9 | shell: Rscript {0} 10 | -------------------------------------------------------------------------------- /.github/workflows/pkgdown-deploy/action.yml: -------------------------------------------------------------------------------- 1 | name: "Action to deploy a pkgdown website" 2 | 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Deploy site 7 | uses: nick-fields/retry@v3 8 | with: 9 | timeout_minutes: 15 10 | max_attempts: 10 11 | command: | 12 | R -q -e 'pkgdown::deploy_to_branch(new_process = FALSE)' 13 | -------------------------------------------------------------------------------- /.github/workflows/rate-limit/action.yml: -------------------------------------------------------------------------------- 1 | name: "Check GitHub rate limits" 2 | inputs: 3 | token: # id of input 4 | description: GitHub token, pass secrets.GITHUB_TOKEN 5 | required: true 6 | 7 | runs: 8 | using: "composite" 9 | steps: 10 | - name: Check rate limits 11 | run: | 12 | curl -s --header "authorization: Bearer ${{ inputs.token }}" https://api.github.com/rate_limit 13 | shell: bash 14 | -------------------------------------------------------------------------------- /.github/workflows/roxygenize/action.yml: -------------------------------------------------------------------------------- 1 | name: "Action to create documentation with roxygen2" 2 | 3 | runs: 4 | using: "composite" 5 | steps: 6 | - name: Roxygenize 7 | run: | 8 | try(roxygen2::roxygenize()) 9 | shell: Rscript {0} 10 | -------------------------------------------------------------------------------- /.github/workflows/versions-matrix/action.yml: -------------------------------------------------------------------------------- 1 | name: "Actions to compute a matrix with all R and OS versions" 2 | 3 | outputs: 4 | matrix: 5 | description: "Generated matrix" 6 | value: ${{ steps.set-matrix.outputs.matrix }} 7 | 8 | runs: 9 | using: "composite" 10 | steps: 11 | - name: Install json2yaml 12 | run: | 13 | sudo npm install -g json2yaml 14 | shell: bash 15 | 16 | - id: set-matrix 17 | run: | 18 | Rscript ./.github/workflows/versions-matrix/action.R 19 | shell: bash 20 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .Rproj.user 2 | .Rhistory 3 | .RData 4 | src/*.d 5 | src/*.h.gch 6 | /clion-test.R 7 | windows/* 8 | CRAN-RELEASE 9 | tests/testthat/testthat-problems.rds 10 | configure.log 11 | .deps/ 12 | autobrew 13 | cleanup 14 | .vscode 15 | .Renviron 16 | CRAN-SUBMISSION 17 | /vscode-*build 18 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Generated by cynkrathis::use_cmakelists(), do not edit by hand 2 | # 3 | # Call: 4 | # quote(cynkrathis::use_cmakelists()) 5 | 6 | cmake_minimum_required(VERSION 3.14) 7 | project(RPostgres VERSION 0.1.0) 8 | 9 | set(CMAKE_EXPORT_COMPILE_COMMANDS ON) 10 | 11 | add_subdirectory(src) 12 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM ghcr.io/cynkra/rig-ubuntu:main 2 | 3 | RUN apt-get update && apt-get install -y gnupg lsb-release time postgresql-client 4 | 5 | RUN mkdir -p /root/workspace 6 | 7 | COPY DESCRIPTION /root/workspace 8 | 9 | RUN R -q -e 'pak::pak(dependencies = c("soft", "Config/Needs/build"))' 10 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | YEAR: 2023 2 | COPYRIGHT HOLDER: RPostgres authors 3 | -------------------------------------------------------------------------------- /R/PqDriver.R: -------------------------------------------------------------------------------- 1 | #' Postgres driver 2 | #' 3 | #' @export 4 | #' @useDynLib RPostgres, .registration = TRUE 5 | #' @import methods DBI 6 | Postgres <- function() { 7 | new("PqDriver") 8 | } 9 | 10 | #' PqDriver and methods. 11 | #' 12 | #' @export 13 | #' @keywords internal 14 | setClass("PqDriver", contains = "DBIDriver") 15 | 16 | # Set during installation time for the correct library 17 | PACKAGE_VERSION <- utils::packageVersion(utils::packageName()) 18 | -------------------------------------------------------------------------------- /R/RPostgres-pkg.R: -------------------------------------------------------------------------------- 1 | #' @importFrom hms hms 2 | #' @importFrom bit64 integer64 3 | "_PACKAGE" 4 | -------------------------------------------------------------------------------- /R/Redshift.R: -------------------------------------------------------------------------------- 1 | #' Redshift driver/connection 2 | #' 3 | #' Use `drv = Redshift()` instead of `drv = Postgres()` to connect to an AWS Redshift cluster. 4 | #' All methods in \pkg{RPostgres} and downstream packages can be called on such connections. 5 | #' Some have different behavior for Redshift connections, to ensure better interoperability. 6 | #' 7 | #' @inheritParams Postgres 8 | #' @export 9 | Redshift <- function() { 10 | new("RedshiftDriver") 11 | } 12 | 13 | #' @export 14 | #' @rdname Redshift 15 | setClass("RedshiftDriver", contains = "PqDriver") 16 | 17 | #' @export 18 | #' @rdname Redshift 19 | setClass("RedshiftConnection", contains = "PqConnection") 20 | -------------------------------------------------------------------------------- /R/dbAppendTable_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @description [dbAppendTable()] is overridden because \pkg{RPostgres} 2 | #' uses placeholders of the form `$1`, `$2` etc. instead of `?`. 3 | #' @name postgres-tables 4 | #' @usage NULL 5 | dbAppendTable_PqConnection <- function(conn, name, value, copy = NULL, ..., row.names = NULL) { 6 | stopifnot(is.null(row.names)) 7 | stopifnot(is.data.frame(value)) 8 | db_append_table(conn, name, value, copy = copy, warn = TRUE) 9 | } 10 | 11 | #' @rdname postgres-tables 12 | #' @export 13 | setMethod("dbAppendTable", "PqConnection", dbAppendTable_PqConnection) 14 | -------------------------------------------------------------------------------- /R/dbBegin_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @param name If provided, uses the `SAVEPOINT` SQL syntax 2 | #' to establish, remove (commit) or undo a ßsavepoint. 3 | #' @name postgres-transactions 4 | #' @usage NULL 5 | dbBegin_PqConnection <- function(conn, ..., name = NULL) { 6 | if (is.null(name)) { 7 | if (connection_is_transacting(conn@ptr)) { 8 | stop("Nested transactions not supported.", call. = FALSE) 9 | } 10 | dbExecute(conn, "BEGIN") 11 | connection_set_transacting(conn@ptr, TRUE) 12 | } else { 13 | if (!connection_is_transacting(conn@ptr)) { 14 | stop("Savepoints require an active transaction.", call. = FALSE) 15 | } 16 | dbExecute(conn, paste0("SAVEPOINT ", dbQuoteIdentifier(conn, name))) 17 | } 18 | invisible(TRUE) 19 | } 20 | 21 | #' @rdname postgres-transactions 22 | #' @export 23 | setMethod("dbBegin", "PqConnection", dbBegin_PqConnection) 24 | -------------------------------------------------------------------------------- /R/dbBind_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-query 2 | #' @usage NULL 3 | dbBind_PqResult <- function(res, params, ...) { 4 | if (!is.null(names(params))) { 5 | stopc("`params` must not be named.") 6 | } 7 | if (!is.list(params)) params <- as.list(params) 8 | 9 | params <- factor_to_string(params, warn = TRUE) 10 | params <- fix_posixt(params, res@conn@timezone) 11 | params <- difftime_to_hms(params) 12 | params <- fix_numeric(params) 13 | params <- prepare_for_binding(params) 14 | result_bind(res@ptr, params) 15 | invisible(res) 16 | } 17 | 18 | #' @rdname postgres-query 19 | #' @export 20 | setMethod("dbBind", "PqResult", dbBind_PqResult) 21 | -------------------------------------------------------------------------------- /R/dbClearResult_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-query 2 | #' @usage NULL 3 | dbClearResult_PqResult <- function(res, ...) { 4 | if (!dbIsValid(res)) { 5 | warningc("Expired, result set already closed") 6 | return(invisible(TRUE)) 7 | } 8 | result_release(res@ptr) 9 | invisible(TRUE) 10 | } 11 | 12 | #' @rdname postgres-query 13 | #' @export 14 | setMethod("dbClearResult", "PqResult", dbClearResult_PqResult) 15 | -------------------------------------------------------------------------------- /R/dbColumnInfo_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbColumnInfo_PqResult <- function(res, ...) { 4 | rci <- result_column_info(res@ptr) 5 | rci <- cbind(rci, .typname = type_lookup(rci[[".oid"]], res@conn), stringsAsFactors = FALSE) 6 | rci 7 | } 8 | 9 | #' @rdname PqResult-class 10 | #' @export 11 | setMethod("dbColumnInfo", "PqResult", dbColumnInfo_PqResult) 12 | -------------------------------------------------------------------------------- /R/dbCommit_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-transactions 2 | #' @usage NULL 3 | dbCommit_PqConnection <- function(conn, ..., name = NULL) { 4 | if (is.null(name)) { 5 | if (!connection_is_transacting(conn@ptr)) { 6 | stop("Call dbBegin() to start a transaction.", call. = FALSE) 7 | } 8 | dbExecute(conn, "COMMIT") 9 | connection_set_transacting(conn@ptr, FALSE) 10 | } else { 11 | dbExecute(conn, paste0("RELEASE SAVEPOINT ", dbQuoteIdentifier(conn, name))) 12 | } 13 | invisible(TRUE) 14 | } 15 | 16 | #' @rdname postgres-transactions 17 | #' @export 18 | setMethod("dbCommit", "PqConnection", dbCommit_PqConnection) 19 | -------------------------------------------------------------------------------- /R/dbConnect_RedshiftDriver.R: -------------------------------------------------------------------------------- 1 | #' @rdname Redshift 2 | #' @usage NULL 3 | dbConnect_RedshiftDriver <- function(drv, dbname = NULL, 4 | host = NULL, port = NULL, password = NULL, user = NULL, service = NULL, ..., 5 | bigint = c("integer64", "integer", "numeric", "character"), 6 | check_interrupts = FALSE, timezone = "UTC") { 7 | new("RedshiftConnection", callNextMethod()) 8 | } 9 | 10 | #' @rdname Redshift 11 | #' @export 12 | setMethod("dbConnect", "RedshiftDriver", dbConnect_RedshiftDriver) 13 | -------------------------------------------------------------------------------- /R/dbDataType_PqConnection.R: -------------------------------------------------------------------------------- 1 | # dbSendQuery() 2 | # dbSendStatement() 3 | # dbDataType() 4 | #' @rdname dbDataType 5 | #' @usage NULL 6 | dbDataType_PqConnection <- function(dbObj, obj, ...) { 7 | if (is.data.frame(obj)) return(vapply(obj, dbDataType, "", dbObj = dbObj)) 8 | get_data_type(obj) 9 | } 10 | 11 | #' @rdname dbDataType 12 | #' @export 13 | setMethod("dbDataType", "PqConnection", dbDataType_PqConnection) 14 | -------------------------------------------------------------------------------- /R/dbDataType_PqDriver.R: -------------------------------------------------------------------------------- 1 | #' Determine database type for R vector. 2 | #' 3 | #' @param dbObj Postgres driver or connection. 4 | #' @param obj Object to convert 5 | #' @keywords internal 6 | #' @rdname dbDataType 7 | #' @usage NULL 8 | dbDataType_PqDriver <- function(dbObj, obj, ...) { 9 | if (is.data.frame(obj)) return(vapply(obj, dbDataType, "", dbObj = dbObj)) 10 | get_data_type(obj) 11 | } 12 | 13 | #' @rdname dbDataType 14 | #' @export 15 | setMethod("dbDataType", "PqDriver", dbDataType_PqDriver) 16 | -------------------------------------------------------------------------------- /R/dbDisconnect_PqConnection.R: -------------------------------------------------------------------------------- 1 | # dbDisconnect() (after dbConnect() to maintain order in documentation) 2 | #' @rdname Postgres 3 | #' @usage NULL 4 | dbDisconnect_PqConnection <- function(conn, ...) { 5 | connection_release(conn@ptr) 6 | invisible(TRUE) 7 | } 8 | 9 | #' @rdname Postgres 10 | #' @export 11 | setMethod("dbDisconnect", "PqConnection", dbDisconnect_PqConnection) 12 | -------------------------------------------------------------------------------- /R/dbExistsTable_PqConnection_Id.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @usage NULL 3 | dbExistsTable_PqConnection_Id <- function(conn, name, ...) { 4 | exists_table(conn, id = name) 5 | } 6 | 7 | #' @rdname postgres-tables 8 | #' @export 9 | setMethod("dbExistsTable", c("PqConnection", "Id"), dbExistsTable_PqConnection_Id) 10 | -------------------------------------------------------------------------------- /R/dbExistsTable_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @usage NULL 3 | dbExistsTable_PqConnection_character <- function(conn, name, ...) { 4 | stopifnot(length(name) == 1L) 5 | # use (Un)QuoteIdentifier roundtrip instead of Id(table = name) 6 | # so that quoted names (possibly incl. schema) can be passed to `name` e.g. 7 | # name = dbQuoteIdentifier(conn, Id(schema = "sname", table = "tname")) 8 | quoted <- dbQuoteIdentifier(conn, name) 9 | id <- dbUnquoteIdentifier(conn, quoted)[[1]] 10 | exists_table(conn, id) 11 | } 12 | 13 | #' @rdname postgres-tables 14 | #' @export 15 | setMethod("dbExistsTable", c("PqConnection", "character"), dbExistsTable_PqConnection_character) 16 | -------------------------------------------------------------------------------- /R/dbFetch_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @param res Code a [PqResult-class] produced by 2 | #' [DBI::dbSendQuery()]. 3 | #' @param n Number of rows to return. If less than zero returns all rows. 4 | #' @inheritParams DBI::sqlRownamesToColumn 5 | #' @rdname postgres-query 6 | #' @usage NULL 7 | dbFetch_PqResult <- function(res, n = -1, ..., row.names = FALSE) { 8 | if (length(n) != 1) stopc("n must be scalar") 9 | if (n < -1) stopc("n must be nonnegative or -1") 10 | if (is.infinite(n)) n <- -1 11 | if (trunc(n) != n) stopc("n must be a whole number") 12 | ret <- sqlColumnToRownames(result_fetch(res@ptr, n = n), row.names) 13 | ret <- convert_bigint(ret, res@bigint) 14 | ret <- finalize_types(ret, res@conn) 15 | ret <- fix_timezone(ret, res@conn) 16 | ret 17 | } 18 | 19 | #' @rdname postgres-query 20 | #' @export 21 | setMethod("dbFetch", "PqResult", dbFetch_PqResult) 22 | -------------------------------------------------------------------------------- /R/dbGetInfo_PqConnection.R: -------------------------------------------------------------------------------- 1 | # dbQuoteString() 2 | # dbQuoteIdentifier() 3 | # dbWriteTable() 4 | # dbReadTable() 5 | # dbListTables() 6 | # dbExistsTable() 7 | # dbListFields() 8 | # dbRemoveTable() 9 | # dbGetInfo() 10 | #' @rdname PqConnection-class 11 | #' @usage NULL 12 | dbGetInfo_PqConnection <- function(dbObj, ...) { 13 | connection_info(dbObj@ptr) 14 | } 15 | 16 | #' @rdname PqConnection-class 17 | #' @export 18 | setMethod("dbGetInfo", "PqConnection", dbGetInfo_PqConnection) 19 | -------------------------------------------------------------------------------- /R/dbGetInfo_PqDriver.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqDriver-class 2 | #' @usage NULL 3 | dbGetInfo_PqDriver <- function(dbObj, ...) { 4 | client_version <- client_version() 5 | major <- client_version %/% 10000 6 | minor <- (client_version - major * 10000) %/% 100 7 | rev <- client_version - major * 10000 - minor * 100 8 | 9 | if (major >= 10) { 10 | client_version <- package_version(paste0(major, ".", rev)) 11 | } else { 12 | client_version <- package_version(paste0(major, ".", minor, ".", rev)) 13 | } 14 | 15 | list( 16 | driver.version = PACKAGE_VERSION, 17 | client.version = client_version 18 | ) 19 | } 20 | 21 | #' @rdname PqDriver-class 22 | #' @export 23 | setMethod("dbGetInfo", "PqDriver", dbGetInfo_PqDriver) 24 | -------------------------------------------------------------------------------- /R/dbGetRowCount_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbGetRowCount_PqResult <- function(res, ...) { 4 | result_rows_fetched(res@ptr) 5 | } 6 | 7 | #' @rdname PqResult-class 8 | #' @export 9 | setMethod("dbGetRowCount", "PqResult", dbGetRowCount_PqResult) 10 | -------------------------------------------------------------------------------- /R/dbGetRowsAffected_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbGetRowsAffected_PqResult <- function(res, ...) { 4 | result_rows_affected(res@ptr) 5 | } 6 | 7 | #' @rdname PqResult-class 8 | #' @export 9 | setMethod("dbGetRowsAffected", "PqResult", dbGetRowsAffected_PqResult) 10 | -------------------------------------------------------------------------------- /R/dbGetStatement_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbGetStatement_PqResult <- function(res, ...) { 4 | if (!dbIsValid(res)) { 5 | stop("Invalid result set.", call. = FALSE) 6 | } 7 | res@sql 8 | } 9 | 10 | #' @rdname PqResult-class 11 | #' @export 12 | setMethod("dbGetStatement", "PqResult", dbGetStatement_PqResult) 13 | -------------------------------------------------------------------------------- /R/dbHasCompleted_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-query 2 | #' @usage NULL 3 | dbHasCompleted_PqResult <- function(res, ...) { 4 | result_has_completed(res@ptr) 5 | } 6 | 7 | #' @rdname postgres-query 8 | #' @export 9 | setMethod("dbHasCompleted", "PqResult", dbHasCompleted_PqResult) 10 | -------------------------------------------------------------------------------- /R/dbIsValid_PqConnection.R: -------------------------------------------------------------------------------- 1 | # dbIsValid() 2 | #' @rdname PqConnection-class 3 | #' @usage NULL 4 | dbIsValid_PqConnection <- function(dbObj, ...) { 5 | connection_valid(dbObj@ptr) 6 | } 7 | 8 | #' @rdname PqConnection-class 9 | #' @export 10 | setMethod("dbIsValid", "PqConnection", dbIsValid_PqConnection) 11 | -------------------------------------------------------------------------------- /R/dbIsValid_PqDriver.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbIsValid_PqDriver <- function(dbObj, ...) { 4 | TRUE 5 | } 6 | 7 | #' @rdname PqResult-class 8 | #' @export 9 | setMethod("dbIsValid", "PqDriver", dbIsValid_PqDriver) 10 | -------------------------------------------------------------------------------- /R/dbIsValid_PqResult.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqResult-class 2 | #' @usage NULL 3 | dbIsValid_PqResult <- function(dbObj, ...) { 4 | result_valid(dbObj@ptr) 5 | } 6 | 7 | #' @rdname PqResult-class 8 | #' @export 9 | setMethod("dbIsValid", "PqResult", dbIsValid_PqResult) 10 | -------------------------------------------------------------------------------- /R/dbListFields_PqConnection_Id.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @usage NULL 3 | dbListFields_PqConnection_Id <- function(conn, name, ...) { 4 | list_fields(conn, id = name) 5 | } 6 | 7 | #' @rdname postgres-tables 8 | #' @export 9 | setMethod("dbListFields", c("PqConnection", "Id"), dbListFields_PqConnection_Id) 10 | -------------------------------------------------------------------------------- /R/dbListFields_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @usage NULL 3 | dbListFields_PqConnection_character <- function(conn, name, ...) { 4 | quoted <- dbQuoteIdentifier(conn, name) 5 | id <- dbUnquoteIdentifier(conn, quoted)[[1]] 6 | 7 | list_fields(conn, id) 8 | } 9 | 10 | #' @rdname postgres-tables 11 | #' @export 12 | setMethod("dbListFields", c("PqConnection", "character"), dbListFields_PqConnection_character) 13 | -------------------------------------------------------------------------------- /R/dbListTables_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @usage NULL 3 | dbListTables_PqConnection <- function(conn, ...) { 4 | query <- list_tables(conn = conn, order_by = "table_type, table_name") 5 | 6 | dbGetQuery(conn, query)[["table_name"]] 7 | } 8 | 9 | #' @rdname postgres-tables 10 | #' @export 11 | setMethod("dbListTables", "PqConnection", dbListTables_PqConnection) 12 | -------------------------------------------------------------------------------- /R/dbQuoteIdentifier_PqConnection_Id.R: -------------------------------------------------------------------------------- 1 | #' @name quote 2 | #' @usage NULL 3 | dbQuoteIdentifier_PqConnection_Id <- function(conn, x, ...) { 4 | SQL(paste0(dbQuoteIdentifier(conn, x@name), collapse = ".")) 5 | } 6 | 7 | #' @rdname quote 8 | #' @export 9 | setMethod("dbQuoteIdentifier", c("PqConnection", "Id"), dbQuoteIdentifier_PqConnection_Id) 10 | -------------------------------------------------------------------------------- /R/dbQuoteIdentifier_PqConnection_SQL.R: -------------------------------------------------------------------------------- 1 | #' @rdname quote 2 | #' @usage NULL 3 | dbQuoteIdentifier_PqConnection_SQL <- function(conn, x, ...) { 4 | x 5 | } 6 | 7 | #' @rdname quote 8 | #' @export 9 | setMethod("dbQuoteIdentifier", c("PqConnection", "SQL"), dbQuoteIdentifier_PqConnection_SQL) 10 | -------------------------------------------------------------------------------- /R/dbQuoteIdentifier_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @rdname quote 2 | #' @usage NULL 3 | dbQuoteIdentifier_PqConnection_character <- function(conn, x, ...) { 4 | if (anyNA(x)) { 5 | stop("Cannot pass NA to dbQuoteIdentifier()", call. = FALSE) 6 | } 7 | SQL(connection_quote_identifier(conn@ptr, x), names = names(x)) 8 | } 9 | 10 | #' @rdname quote 11 | #' @export 12 | setMethod("dbQuoteIdentifier", c("PqConnection", "character"), dbQuoteIdentifier_PqConnection_character) 13 | -------------------------------------------------------------------------------- /R/dbQuoteString_PqConnection_SQL.R: -------------------------------------------------------------------------------- 1 | #' @rdname quote 2 | #' @usage NULL 3 | dbQuoteString_PqConnection_SQL <- function(conn, x, ...) { 4 | x 5 | } 6 | 7 | #' @rdname quote 8 | #' @export 9 | setMethod("dbQuoteString", c("PqConnection", "SQL"), dbQuoteString_PqConnection_SQL) 10 | -------------------------------------------------------------------------------- /R/dbQuoteString_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @rdname quote 2 | #' @usage NULL 3 | dbQuoteString_PqConnection_character <- function(conn, x, ...) { 4 | if (length(x) == 0) return(SQL(character())) 5 | if (is(conn, "RedshiftConnection")) { 6 | out <- paste0("'", gsub("(['\\\\])", "\\1\\1", enc2utf8(x)), "'") 7 | out[is.na(x)] <- "NULL::varchar(max)" 8 | } else { 9 | out <- connection_quote_string(conn@ptr, enc2utf8(x)) 10 | } 11 | SQL(out) 12 | } 13 | 14 | #' @rdname quote 15 | #' @export 16 | setMethod("dbQuoteString", c("PqConnection", "character"), dbQuoteString_PqConnection_character) 17 | -------------------------------------------------------------------------------- /R/dbReadTable_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @param check.names If `TRUE`, the default, column names will be 2 | #' converted to valid R identifiers. 3 | #' @rdname postgres-tables 4 | #' @usage NULL 5 | dbReadTable_PqConnection_character <- function(conn, name, ..., check.names = TRUE, row.names = FALSE) { 6 | if (is.null(row.names)) row.names <- FALSE 7 | if ((!is.logical(row.names) && !is.character(row.names)) || length(row.names) != 1L) { 8 | stopc("`row.names` must be a logical scalar or a string") 9 | } 10 | 11 | if (!is.logical(check.names) || length(check.names) != 1L) { 12 | stopc("`check.names` must be a logical scalar") 13 | } 14 | 15 | name <- dbQuoteIdentifier(conn, name) 16 | out <- dbGetQuery(conn, paste("SELECT * FROM ", name), row.names = row.names) 17 | 18 | if (check.names) { 19 | names(out) <- make.names(names(out), unique = TRUE) 20 | } 21 | 22 | out 23 | } 24 | 25 | #' @rdname postgres-tables 26 | #' @export 27 | setMethod("dbReadTable", c("PqConnection", "character"), dbReadTable_PqConnection_character) 28 | -------------------------------------------------------------------------------- /R/dbRemoveTable_PqConnection_character.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-tables 2 | #' @param temporary If `TRUE`, only temporary tables are considered. 3 | #' @param fail_if_missing If `FALSE`, `dbRemoveTable()` succeeds if the 4 | #' table doesn't exist. 5 | #' @usage NULL 6 | dbRemoveTable_PqConnection_character <- function(conn, name, ..., temporary = FALSE, fail_if_missing = TRUE) { 7 | name <- dbQuoteIdentifier(conn, name) 8 | if (fail_if_missing) { 9 | extra <- "" 10 | } else { 11 | extra <- "IF EXISTS " 12 | } 13 | if (temporary) { 14 | temp_schema <- find_temp_schema(conn, fail_if_missing) 15 | if (is.null(temp_schema)) return(invisible(TRUE)) 16 | extra <- paste0(extra, temp_schema, ".") 17 | } 18 | dbExecute(conn, paste0("DROP TABLE ", extra, name)) 19 | invisible(TRUE) 20 | } 21 | 22 | #' @rdname postgres-tables 23 | #' @export 24 | setMethod("dbRemoveTable", c("PqConnection", "character"), dbRemoveTable_PqConnection_character) 25 | -------------------------------------------------------------------------------- /R/dbRollback_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @rdname postgres-transactions 2 | #' @usage NULL 3 | dbRollback_PqConnection <- function(conn, ..., name = NULL) { 4 | if (is.null(name)) { 5 | if (!connection_is_transacting(conn@ptr)) { 6 | stop("Call dbBegin() to start a transaction.", call. = FALSE) 7 | } 8 | dbExecute(conn, "ROLLBACK") 9 | connection_set_transacting(conn@ptr, FALSE) 10 | } else { 11 | name_quoted <- dbQuoteIdentifier(conn, name) 12 | dbExecute(conn, paste0("ROLLBACK TO ", name_quoted)) 13 | dbExecute(conn, paste0("RELEASE SAVEPOINT ", name_quoted)) 14 | } 15 | invisible(TRUE) 16 | } 17 | 18 | #' @rdname postgres-transactions 19 | #' @export 20 | setMethod("dbRollback", "PqConnection", dbRollback_PqConnection) 21 | -------------------------------------------------------------------------------- /R/dbUnloadDriver_PqDriver.R: -------------------------------------------------------------------------------- 1 | #' @rdname PqDriver-class 2 | #' @usage NULL 3 | dbUnloadDriver_PqDriver <- function(drv, ...) { 4 | NULL 5 | } 6 | 7 | #' @rdname PqDriver-class 8 | #' @export 9 | setMethod("dbUnloadDriver", "PqDriver", dbUnloadDriver_PqDriver) 10 | -------------------------------------------------------------------------------- /R/dbUnquoteIdentifier_PqConnection_SQL.R: -------------------------------------------------------------------------------- 1 | #' @rdname quote 2 | #' @usage NULL 3 | dbUnquoteIdentifier_PqConnection_SQL <- function(conn, x, ...) { 4 | id_rx <- '(?:"((?:[^"]|"")+)"|([^". ]+))' 5 | 6 | rx <- paste0( 7 | "^", 8 | "(?:|(?:|", id_rx, "[.])", 9 | id_rx, "[.])", 10 | "(?:|", id_rx, ")", 11 | "$" 12 | ) 13 | 14 | bad <- grep(rx, x, invert = TRUE) 15 | if (length(bad) > 0) { 16 | stop("Can't unquote ", x[bad[[1]]], call. = FALSE) 17 | } 18 | catalog <- gsub(rx, "\\1\\2", x) 19 | catalog <- gsub('""', '"', catalog) 20 | schema <- gsub(rx, "\\3\\4", x) 21 | schema <- gsub('""', '"', schema) 22 | table <- gsub(rx, "\\5\\6", x) 23 | table <- gsub('""', '"', table) 24 | 25 | ret <- Map(catalog, schema, table, f = as_table) 26 | names(ret) <- names(x) 27 | ret 28 | } 29 | 30 | #' @rdname quote 31 | #' @export 32 | setMethod("dbUnquoteIdentifier", c("PqConnection", "SQL"), dbUnquoteIdentifier_PqConnection_SQL) 33 | -------------------------------------------------------------------------------- /R/quote.R: -------------------------------------------------------------------------------- 1 | #' @include PqConnection.R 2 | NULL 3 | 4 | #' Quote postgres strings, identifiers, and literals 5 | #' 6 | #' If an object of class [Id] is used for `dbQuoteIdentifier()`, it needs 7 | #' at most one `table` component and at most one `schema` component. 8 | #' 9 | #' @param conn A [PqConnection-class] created by `dbConnect()` 10 | #' @param x A character vector to be quoted. 11 | #' @param ... Other arguments needed for compatibility with generic (currently 12 | #' ignored). 13 | #' @examplesIf postgresHasDefault() 14 | #' library(DBI) 15 | #' con <- dbConnect(RPostgres::Postgres()) 16 | #' 17 | #' x <- c("a", "b c", "d'e", "\\f") 18 | #' dbQuoteString(con, x) 19 | #' dbQuoteIdentifier(con, x) 20 | #' dbDisconnect(con) 21 | #' @name quote 22 | NULL 23 | 24 | as_table <- function(catalog, schema, table) { 25 | args <- c(catalog = catalog, schema = schema, table = table) 26 | # Also omits NA args 27 | args <- args[!is.na(args) & args != ""] 28 | do.call(Id, as.list(args)) 29 | } 30 | -------------------------------------------------------------------------------- /R/show_PqConnection.R: -------------------------------------------------------------------------------- 1 | # show() 2 | #' @rdname PqConnection-class 3 | #' @usage NULL 4 | show_PqConnection <- function(object) { 5 | info <- dbGetInfo(object) 6 | 7 | if (info$host == "") { 8 | host <- "socket" 9 | } else { 10 | host <- paste0(info$host, ":", info$port) 11 | } 12 | 13 | cat(" ", info$dbname, "@", host, "\n", sep = "") 14 | } 15 | 16 | #' @rdname PqConnection-class 17 | #' @export 18 | setMethod("show", "PqConnection", show_PqConnection) 19 | -------------------------------------------------------------------------------- /R/sqlData_PqConnection.R: -------------------------------------------------------------------------------- 1 | #' @inheritParams DBI::sqlRownamesToColumn 2 | #' @param ... Ignored. 3 | #' @rdname postgres-tables 4 | #' @usage NULL 5 | sqlData_PqConnection <- function(con, value, row.names = FALSE, ...) { 6 | if (is.null(row.names)) row.names <- FALSE 7 | value <- sqlRownamesToColumn(value, row.names) 8 | 9 | value[] <- lapply(value, dbQuoteLiteral, conn = con) 10 | 11 | value 12 | } 13 | 14 | #' @rdname postgres-tables 15 | #' @export 16 | setMethod("sqlData", "PqConnection", sqlData_PqConnection) 17 | -------------------------------------------------------------------------------- /R/transactions.R: -------------------------------------------------------------------------------- 1 | #' Transaction management. 2 | #' 3 | #' `dbBegin()` starts a transaction. `dbCommit()` and `dbRollback()` 4 | #' end the transaction by either committing or rolling back the changes. 5 | #' 6 | #' @param conn a [PqConnection-class] object, produced by 7 | #' [DBI::dbConnect()] 8 | #' @param ... Unused, for extensibility. 9 | #' @return A boolean, indicating success or failure. 10 | #' @examplesIf postgresHasDefault() 11 | #' library(DBI) 12 | #' con <- dbConnect(RPostgres::Postgres()) 13 | #' dbWriteTable(con, "USarrests", datasets::USArrests, temporary = TRUE) 14 | #' dbGetQuery(con, 'SELECT count(*) from "USarrests"') 15 | #' 16 | #' dbBegin(con) 17 | #' dbExecute(con, 'DELETE from "USarrests" WHERE "Murder" > 1') 18 | #' dbGetQuery(con, 'SELECT count(*) from "USarrests"') 19 | #' dbRollback(con) 20 | #' 21 | #' # Rolling back changes leads to original count 22 | #' dbGetQuery(con, 'SELECT count(*) from "USarrests"') 23 | #' 24 | #' dbRemoveTable(con, "USarrests") 25 | #' dbDisconnect(con) 26 | #' @name postgres-transactions 27 | NULL 28 | -------------------------------------------------------------------------------- /R/utils.R: -------------------------------------------------------------------------------- 1 | vlapply <- function(X, FUN, ..., USE.NAMES = TRUE) { 2 | vapply(X = X, FUN = FUN, FUN.VALUE = logical(1L), ..., USE.NAMES = USE.NAMES) 3 | } 4 | 5 | viapply <- function(X, FUN, ..., USE.NAMES = TRUE) { 6 | vapply(X = X, FUN = FUN, FUN.VALUE = integer(1L), ..., USE.NAMES = USE.NAMES) 7 | } 8 | 9 | vcapply <- function(X, FUN, ..., USE.NAMES = TRUE) { 10 | vapply(X = X, FUN = FUN, FUN.VALUE = character(1L), ..., USE.NAMES = USE.NAMES) 11 | } 12 | 13 | stopc <- function(...) { 14 | stop(..., call. = FALSE, domain = NA) 15 | } 16 | 17 | warningc <- function(...) { 18 | warning(..., call. = FALSE, domain = NA) 19 | } 20 | 21 | try_silent <- function(code) { 22 | tryCatch(code, error = function(e) invisible()) 23 | } 24 | -------------------------------------------------------------------------------- /RPostgres.Rproj: -------------------------------------------------------------------------------- 1 | Version: 1.0 2 | ProjectId: 4868ba19-12d7-4808-bd4e-6793e94bccf2 3 | 4 | RestoreWorkspace: No 5 | SaveWorkspace: No 6 | AlwaysSaveHistory: Default 7 | 8 | EnableCodeIndexing: Yes 9 | UseSpacesForTab: Yes 10 | NumSpacesForTab: 2 11 | Encoding: UTF-8 12 | 13 | RnwWeave: Sweave 14 | LaTeX: pdfLaTeX 15 | 16 | AutoAppendNewline: Yes 17 | StripTrailingWhitespace: Yes 18 | 19 | BuildType: Package 20 | PackageUseDevtools: Yes 21 | PackageInstallArgs: --no-multiarch --with-keep.source --no-byte-compile 22 | PackageRoxygenize: rd,collate,namespace 23 | -------------------------------------------------------------------------------- /codecov.yml: -------------------------------------------------------------------------------- 1 | comment: false 2 | 3 | coverage: 4 | status: 5 | project: 6 | default: 7 | target: auto 8 | threshold: 1% 9 | patch: 10 | default: 11 | target: auto 12 | threshold: 1% 13 | -------------------------------------------------------------------------------- /configure.win: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/r-dbi/RPostgres/3386d7abdb7d245f23a10f801062575e63e25c55/configure.win -------------------------------------------------------------------------------- /cran-comments.md: -------------------------------------------------------------------------------- 1 | RPostgres 1.4.7.9900 2 | 3 | ## Cran Repository Policy 4 | 5 | - [x] Reviewed CRP last edited 2024-08-27. 6 | -------------------------------------------------------------------------------- /docker-compose.yml: -------------------------------------------------------------------------------- 1 | # See .github/CONTRIBUTING.md for details. 2 | 3 | version: '3' 4 | volumes: 5 | postgres-socket: 6 | driver: local 7 | 8 | services: 9 | # https://geshan.com.np/blog/2021/12/docker-postgres/ 10 | # https://community.home-assistant.io/t/timescaledb-postgres-using-a-unix-socket-in-docker-compose-as-ha-database/247136/2 11 | postgres: 12 | container_name: postgres 13 | image: postgres 14 | environment: 15 | POSTGRES_USER: root 16 | POSTGRES_PASSWORD: "YourStrong!Passw0rd" 17 | volumes: 18 | - postgres-socket:/var/run/postgresql 19 | ports: 20 | - "5432:5432" 21 | 22 | workspace: 23 | container_name: workspace 24 | image: ghcr.io/r-dbi/rpostgres:main 25 | platform: linux/amd64 26 | environment: 27 | TESTTHAT_CPUS: 4 28 | volumes: 29 | - ${PWD}:/root/workspace 30 | - postgres-socket:/var/run/postgresql 31 | -------------------------------------------------------------------------------- /man/PqConnection-class.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/PqConnection.R, R/dbGetInfo_PqConnection.R, 3 | % R/dbIsValid_PqConnection.R, R/show_PqConnection.R 4 | \docType{class} 5 | \name{PqConnection-class} 6 | \alias{PqConnection-class} 7 | \alias{format.PqConnection} 8 | \alias{dbGetInfo_PqConnection} 9 | \alias{dbGetInfo,PqConnection-method} 10 | \alias{dbIsValid_PqConnection} 11 | \alias{dbIsValid,PqConnection-method} 12 | \alias{show_PqConnection} 13 | \alias{show,PqConnection-method} 14 | \title{PqConnection and methods.} 15 | \usage{ 16 | \method{format}{PqConnection}(x, ...) 17 | 18 | \S4method{dbGetInfo}{PqConnection}(dbObj, ...) 19 | 20 | \S4method{dbIsValid}{PqConnection}(dbObj, ...) 21 | 22 | \S4method{show}{PqConnection}(object) 23 | } 24 | \description{ 25 | PqConnection and methods. 26 | } 27 | \keyword{internal} 28 | -------------------------------------------------------------------------------- /man/PqDriver-class.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/PqDriver.R, R/dbGetInfo_PqDriver.R, 3 | % R/dbUnloadDriver_PqDriver.R 4 | \docType{class} 5 | \name{PqDriver-class} 6 | \alias{PqDriver-class} 7 | \alias{dbGetInfo_PqDriver} 8 | \alias{dbGetInfo,PqDriver-method} 9 | \alias{dbUnloadDriver_PqDriver} 10 | \alias{dbUnloadDriver,PqDriver-method} 11 | \title{PqDriver and methods.} 12 | \usage{ 13 | \S4method{dbGetInfo}{PqDriver}(dbObj, ...) 14 | 15 | \S4method{dbUnloadDriver}{PqDriver}(drv, ...) 16 | } 17 | \description{ 18 | PqDriver and methods. 19 | } 20 | \keyword{internal} 21 | -------------------------------------------------------------------------------- /man/dbDataType.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/dbDataType_PqConnection.R, 3 | % R/dbDataType_PqDriver.R 4 | \name{dbDataType_PqConnection} 5 | \alias{dbDataType_PqConnection} 6 | \alias{dbDataType,PqConnection-method} 7 | \alias{dbDataType_PqDriver} 8 | \alias{dbDataType,PqDriver-method} 9 | \title{Determine database type for R vector.} 10 | \usage{ 11 | \S4method{dbDataType}{PqConnection}(dbObj, obj, ...) 12 | 13 | \S4method{dbDataType}{PqDriver}(dbObj, obj, ...) 14 | } 15 | \arguments{ 16 | \item{dbObj}{Postgres driver or connection.} 17 | 18 | \item{obj}{Object to convert} 19 | } 20 | \description{ 21 | Determine database type for R vector. 22 | } 23 | \keyword{internal} 24 | -------------------------------------------------------------------------------- /man/postgresImportLargeObject.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/PqConnection.R 3 | \name{postgresImportLargeObject} 4 | \alias{postgresImportLargeObject} 5 | \title{Imports a large object from file} 6 | \usage{ 7 | postgresImportLargeObject(conn, filepath = NULL, oid = 0) 8 | } 9 | \arguments{ 10 | \item{conn}{a \linkS4class{PqConnection} object, produced by 11 | \code{\link[DBI:dbConnect]{DBI::dbConnect()}}} 12 | 13 | \item{filepath}{a path to the large object to import} 14 | 15 | \item{oid}{the oid to write to. Defaults to 0 which assigns an unused oid} 16 | } 17 | \value{ 18 | the identifier of the large object, an integer 19 | } 20 | \description{ 21 | Returns an object idenfier (Oid) for the imported large object 22 | } 23 | \examples{ 24 | \dontrun{ 25 | con <- postgresDefault() 26 | filepath <- 'your_image.png' 27 | dbWithTransaction(con, { 28 | oid <- postgresImportLargeObject(con, filepath) 29 | }) 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /man/postgresIsTransacting.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/PqConnection.R 3 | \name{postgresIsTransacting} 4 | \alias{postgresIsTransacting} 5 | \title{Return whether a transaction is ongoing} 6 | \usage{ 7 | postgresIsTransacting(conn) 8 | } 9 | \arguments{ 10 | \item{conn}{a \linkS4class{PqConnection} object, produced by 11 | \code{\link[DBI:dbConnect]{DBI::dbConnect()}}} 12 | } 13 | \value{ 14 | A boolean, indicating if a transaction is ongoing. 15 | } 16 | \description{ 17 | Detect whether the transaction is active for the given connection. A 18 | transaction might be started with \code{\link[DBI:transactions]{DBI::dbBegin()}} or wrapped within 19 | \code{\link[DBI:dbWithTransaction]{DBI::dbWithTransaction()}}. 20 | } 21 | -------------------------------------------------------------------------------- /man/reexports.Rd: -------------------------------------------------------------------------------- 1 | % Generated by roxygen2: do not edit by hand 2 | % Please edit documentation in R/export.R 3 | \docType{import} 4 | \name{reexports} 5 | \alias{reexports} 6 | \alias{Id} 7 | \title{Objects exported from other packages} 8 | \keyword{internal} 9 | \description{ 10 | These objects are imported from other packages. Follow the links 11 | below to see their documentation. 12 | 13 | \describe{ 14 | \item{DBI}{\code{\link[DBI]{Id}}} 15 | }} 16 | 17 | -------------------------------------------------------------------------------- /src/.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.so 3 | *.dll 4 | Makevars 5 | -------------------------------------------------------------------------------- /src/DbColumnDataSource.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "DbColumnDataSource.h" 3 | 4 | DbColumnDataSource::DbColumnDataSource(const int j_) : 5 | j(j_) 6 | { 7 | } 8 | 9 | DbColumnDataSource::~DbColumnDataSource() { 10 | } 11 | 12 | int DbColumnDataSource::get_j() const { 13 | return j; 14 | } 15 | -------------------------------------------------------------------------------- /src/DbColumnDataSource.h: -------------------------------------------------------------------------------- 1 | #ifndef DB_COLUMNDATASOURCE_H 2 | #define DB_COLUMNDATASOURCE_H 3 | 4 | #include "DbColumnDataType.h" 5 | 6 | class DbColumnDataSource { 7 | const int j; 8 | 9 | protected: 10 | DbColumnDataSource(const int j); 11 | 12 | public: 13 | virtual ~DbColumnDataSource(); 14 | 15 | public: 16 | virtual DATA_TYPE get_data_type() const = 0; 17 | virtual DATA_TYPE get_decl_data_type() const = 0; 18 | 19 | virtual bool is_null() const = 0; 20 | 21 | virtual int fetch_bool() const = 0; 22 | virtual int fetch_int() const = 0; 23 | virtual int64_t fetch_int64() const = 0; 24 | virtual double fetch_real() const = 0; 25 | virtual SEXP fetch_string() const = 0; 26 | virtual SEXP fetch_blob() const = 0; 27 | virtual double fetch_date() const = 0; 28 | virtual double fetch_datetime_local() const = 0; 29 | virtual double fetch_datetime() const = 0; 30 | virtual double fetch_time() const = 0; 31 | 32 | protected: 33 | int get_j() const; 34 | }; 35 | 36 | #endif //DB_COLUMNDATASOURCE_H 37 | -------------------------------------------------------------------------------- /src/DbColumnDataSourceFactory.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "DbColumnDataSourceFactory.h" 3 | 4 | DbColumnDataSourceFactory::DbColumnDataSourceFactory() { 5 | } 6 | 7 | DbColumnDataSourceFactory::~DbColumnDataSourceFactory() { 8 | } 9 | -------------------------------------------------------------------------------- /src/DbColumnDataSourceFactory.h: -------------------------------------------------------------------------------- 1 | #ifndef DB_COLUMNDATASOURCEFACTORY_H 2 | #define DB_COLUMNDATASOURCEFACTORY_H 3 | 4 | class DbColumnDataSource; 5 | 6 | class DbColumnDataSourceFactory { 7 | protected: 8 | DbColumnDataSourceFactory(); 9 | 10 | public: 11 | virtual ~DbColumnDataSourceFactory(); 12 | 13 | public: 14 | virtual DbColumnDataSource* create(const int j) = 0; 15 | }; 16 | 17 | #endif //DB_COLUMNDATASOURCEFACTORY_H 18 | -------------------------------------------------------------------------------- /src/DbColumnDataType.h: -------------------------------------------------------------------------------- 1 | #ifndef RSQLITE_COLUMNDATATYPE_H 2 | #define RSQLITE_COLUMNDATATYPE_H 3 | 4 | enum DATA_TYPE { 5 | DT_UNKNOWN, 6 | DT_BOOL, 7 | DT_INT, 8 | DT_INT64, 9 | DT_REAL, 10 | DT_STRING, 11 | DT_BLOB, 12 | DT_DATE, 13 | DT_DATETIME, 14 | DT_DATETIMETZ, 15 | DT_TIME 16 | }; 17 | 18 | #endif // RSQLITE_COLUMNDATATYPE_H 19 | -------------------------------------------------------------------------------- /src/DbDataFrame.h: -------------------------------------------------------------------------------- 1 | #ifndef DB_DATAFRAME_H 2 | #define DB_DATAFRAME_H 3 | 4 | #include 5 | #include 6 | #include "DbColumnDataType.h" 7 | 8 | class DbColumn; 9 | class DbColumnDataSourceFactory; 10 | 11 | class DbDataFrame { 12 | boost::scoped_ptr factory; 13 | const int n_max; 14 | int i; 15 | boost::container::stable_vector data; 16 | std::vector names; 17 | 18 | public: 19 | DbDataFrame(DbColumnDataSourceFactory* factory, 20 | std::vector names, 21 | const int n_max_, 22 | const std::vector& types); 23 | virtual ~DbDataFrame(); 24 | 25 | public: 26 | void set_col_values(); 27 | bool advance(); 28 | 29 | cpp11::list get_data(); 30 | cpp11::list get_data(std::vector& types); 31 | size_t get_ncols() const; 32 | 33 | private: 34 | void finalize_cols(); 35 | }; 36 | 37 | 38 | #endif //DB_DATAFRAME_H 39 | -------------------------------------------------------------------------------- /src/DbResult.h: -------------------------------------------------------------------------------- 1 | #ifndef __RDBI_DB_RESULT__ 2 | #define __RDBI_DB_RESULT__ 3 | 4 | #include 5 | #include 6 | #include 7 | 8 | #include "DbResultImplDecl.h" 9 | 10 | 11 | class DbConnection; 12 | typedef boost::shared_ptr DbConnectionPtr; 13 | 14 | // DbResult -------------------------------------------------------------------- 15 | 16 | class DbResult : boost::noncopyable { 17 | DbConnectionPtr pConn_; 18 | 19 | protected: 20 | boost::scoped_ptr impl; 21 | 22 | protected: 23 | DbResult(const DbConnectionPtr& pConn); 24 | 25 | public: 26 | ~DbResult(); 27 | 28 | public: 29 | void close(); 30 | 31 | bool complete() const; 32 | bool is_active() const; 33 | int n_rows_fetched(); 34 | int n_rows_affected(); 35 | 36 | void bind(const cpp11::list& params); 37 | cpp11::list fetch(int n_max = -1); 38 | 39 | cpp11::list get_column_info(); 40 | 41 | private: 42 | void validate_params(const cpp11::list& params) const; 43 | }; 44 | 45 | #endif // __RDBI_DB_RESULT__ 46 | -------------------------------------------------------------------------------- /src/DbResultImpl.h: -------------------------------------------------------------------------------- 1 | #include "PqResultImpl.h" 2 | -------------------------------------------------------------------------------- /src/DbResultImplDecl.h: -------------------------------------------------------------------------------- 1 | class PqResultImpl; 2 | typedef PqResultImpl DbResultImpl; 3 | -------------------------------------------------------------------------------- /src/Makevars.in: -------------------------------------------------------------------------------- 1 | PKG_CPPFLAGS=@cflags@ -Ivendor -DRCPP_DEFAULT_INCLUDE_CALL=false -DRCPP_USING_UTF8_ERROR_STRING -DBOOST_NO_AUTO_PTR @plogr@ 2 | 3 | PKG_CFLAGS=$(C_VISIBILITY) 4 | PKG_CXXFLAGS=$(CXX_VISIBILITY) 5 | 6 | PKG_LIBS=@libs@ 7 | 8 | all: cleanup 9 | 10 | cleanup: $(SHLIB) 11 | @rm -Rf ../.deps 12 | -------------------------------------------------------------------------------- /src/Makevars.win: -------------------------------------------------------------------------------- 1 | PKG_CONFIG_NAME = libpq 2 | PKG_CONFIG ?= $(BINPREF)pkg-config 3 | PKG_LIBS := $(shell $(PKG_CONFIG) --libs $(PKG_CONFIG_NAME)) 4 | EXTRA_CFLAGS = -DRCPP_DEFAULT_INCLUDE_CALL=false -DRCPP_USING_UTF8_ERROR_STRING -DBOOST_NO_AUTO_PTR 5 | 6 | ifneq ($(findstring ldap32,$(PKG_LIBS)),) 7 | $(info using $(PKG_CONFIG_NAME) from Rtools) 8 | PKG_CPPFLAGS := $(shell $(PKG_CONFIG) --cflags $(PKG_CONFIG_NAME)) $(EXTRA_CFLAGS) 9 | else 10 | RWINLIB = ../windows/libpq 11 | PKG_CPPFLAGS = -I$(RWINLIB)/include -Ivendor $(EXTRA_CFLAGS) 12 | PKG_LIBS = -L$(RWINLIB)/lib$(R_ARCH) -L$(RWINLIB)/lib \ 13 | -lpq -lpgport -lpgcommon -lssl -lcrypto -lwsock32 -lsecur32 -lws2_32 -lgdi32 -lcrypt32 -lwldap32 14 | endif 15 | 16 | all: $(SHLIB) 17 | 18 | $(OBJECTS): $(RWINLIB) 19 | 20 | $(RWINLIB): 21 | "${R_HOME}/bin${R_ARCH_BIN}/Rscript.exe" "../tools/winlibs.R" 22 | 23 | clean: 24 | rm -f $(SHLIB) $(OBJECTS) 25 | -------------------------------------------------------------------------------- /src/PqColumnDataSourceFactory.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "PqColumnDataSourceFactory.h" 3 | #include "PqColumnDataSource.h" 4 | 5 | PqColumnDataSourceFactory::PqColumnDataSourceFactory(PqResultSource* result_source_, const std::vector& types_) : 6 | result_source(result_source_), 7 | types(types_) 8 | { 9 | } 10 | 11 | PqColumnDataSourceFactory::~PqColumnDataSourceFactory() { 12 | } 13 | 14 | DbColumnDataSource* PqColumnDataSourceFactory::create(const int j) { 15 | return new PqColumnDataSource(result_source, types[j], j); 16 | } 17 | -------------------------------------------------------------------------------- /src/PqColumnDataSourceFactory.h: -------------------------------------------------------------------------------- 1 | #ifndef RPOSTGRES_PQCOLUMNDATASOURCEFACTORY_H 2 | #define RPOSTGRES_PQCOLUMNDATASOURCEFACTORY_H 3 | 4 | #include "DbColumnDataSourceFactory.h" 5 | #include "DbColumnDataType.h" 6 | 7 | class PqResultSource; 8 | 9 | class PqColumnDataSourceFactory : public DbColumnDataSourceFactory { 10 | PqResultSource* result_source; 11 | const std::vector types; 12 | 13 | public: 14 | PqColumnDataSourceFactory(PqResultSource* result_source_, const std::vector& types_); 15 | virtual ~PqColumnDataSourceFactory(); 16 | 17 | public: 18 | virtual DbColumnDataSource* create(const int j); 19 | }; 20 | 21 | #endif //RPOSTGRES_PQCOLUMNDATASOURCEFACTORY_H 22 | -------------------------------------------------------------------------------- /src/PqDataFrame.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "PqDataFrame.h" 3 | #include "PqColumnDataSourceFactory.h" 4 | 5 | 6 | PqDataFrame::PqDataFrame(PqResultSource* result_source, 7 | const std::vector& names, 8 | const int n_max_, 9 | const std::vector& types) : 10 | DbDataFrame(new PqColumnDataSourceFactory(result_source, types), names, n_max_, types) 11 | { 12 | } 13 | 14 | PqDataFrame::~PqDataFrame() { 15 | } 16 | -------------------------------------------------------------------------------- /src/PqDataFrame.h: -------------------------------------------------------------------------------- 1 | #ifndef RPOSTGRES_PQDATAFRAME_H 2 | #define RPOSTGRES_PQDATAFRAME_H 3 | 4 | #include "DbDataFrame.h" 5 | 6 | class PqResultSource; 7 | 8 | class PqDataFrame : public DbDataFrame { 9 | public: 10 | PqDataFrame(PqResultSource* result_source, 11 | const std::vector& names, 12 | const int n_max_, 13 | const std::vector& types); 14 | ~PqDataFrame(); 15 | }; 16 | 17 | #endif //RPOSTGRES_PQDATAFRAME_H 18 | -------------------------------------------------------------------------------- /src/PqResult.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "PqResult.h" 3 | #include "DbResultImpl.h" 4 | 5 | 6 | 7 | // Construction //////////////////////////////////////////////////////////////// 8 | 9 | PqResult::PqResult(const DbConnectionPtr& pConn, const std::string& sql, const bool immediate) : 10 | DbResult(pConn) 11 | { 12 | impl.reset(new DbResultImpl(pConn, sql, immediate)); 13 | } 14 | 15 | 16 | // Publics ///////////////////////////////////////////////////////////////////// 17 | 18 | DbResult* PqResult::create_and_send_query(const DbConnectionPtr& con, const std::string& sql, const bool immediate) { 19 | return new PqResult(con, sql, immediate); 20 | } 21 | 22 | 23 | // Privates /////////////////////////////////////////////////////////////////// 24 | -------------------------------------------------------------------------------- /src/PqResult.h: -------------------------------------------------------------------------------- 1 | #ifndef __RPOSTGRES_PQ_RESULT__ 2 | #define __RPOSTGRES_PQ_RESULT__ 3 | 4 | #include "DbResult.h" 5 | 6 | // There is no object analogous to DbResult in libpq: this provides a result set 7 | // like object for the R API. There is only ever one active result set (the 8 | // most recent) for each connection. 9 | 10 | class PqResult : public DbResult { 11 | protected: 12 | PqResult(const DbConnectionPtr& pConn, const std::string& sql, const bool immediate); 13 | 14 | public: 15 | static DbResult* create_and_send_query(const DbConnectionPtr& con, const std::string& sql, const bool immediate); 16 | }; 17 | 18 | #endif // __RPOSTGRES_PQ_RESULT__ 19 | -------------------------------------------------------------------------------- /src/PqResultSource.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "PqResultSource.h" 3 | 4 | PqResultSource::PqResultSource() { 5 | } 6 | 7 | PqResultSource::~PqResultSource() { 8 | } 9 | -------------------------------------------------------------------------------- /src/PqResultSource.h: -------------------------------------------------------------------------------- 1 | #ifndef RPOSTGRES_PQRESULTSOURCE_H 2 | #define RPOSTGRES_PQRESULTSOURCE_H 3 | 4 | class PqResultSource { 5 | public: 6 | PqResultSource(); 7 | virtual ~PqResultSource(); 8 | 9 | public: 10 | virtual PGresult* get_result() = 0; 11 | }; 12 | 13 | #endif //RPOSTGRES_PQRESULTSOURCE_H 14 | -------------------------------------------------------------------------------- /src/PqUtils.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include "PqUtils.h" 3 | 4 | // From https://stackoverflow.com/a/40914871/946850: 5 | int days_from_civil(int y, int m, int d) { 6 | y -= m <= 2; 7 | const int era = (y >= 0 ? y : y - 399) / 400; 8 | const int yoe = static_cast(y - era * 400); // [0, 399] 9 | const int doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1; // [0, 365] 10 | const int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; // [0, 146096] 11 | return era * 146097 + doe - 719468; 12 | } 13 | 14 | time_t tm_to_time_t(const tm& tm_) { 15 | const time_t days = days_from_civil(tm_.tm_year + 1900, tm_.tm_mon + 1, tm_.tm_mday); 16 | return days * 86400 + tm_.tm_hour * 60 * 60 + tm_.tm_min * 60 + tm_.tm_sec; 17 | } 18 | -------------------------------------------------------------------------------- /src/PqUtils.h: -------------------------------------------------------------------------------- 1 | #ifndef __RPOSTGRES_MY_UTILS__ 2 | #define __RPOSTGRES_MY_UTILS__ 3 | 4 | int days_from_civil(int y, int m, int d); 5 | time_t tm_to_time_t(const tm& tm_); 6 | 7 | #endif 8 | -------------------------------------------------------------------------------- /src/RPostgres-init.c: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #ifdef _WIN32 4 | #include 5 | #endif 6 | 7 | // From https://www.postgresql.org/docs/current/libpq-connect.html: 8 | // On Windows, there is a way to improve performance if a single database 9 | // connection is repeatedly started and shutdown. Internally, libpq calls 10 | // WSAStartup() and WSACleanup() for connection startup and shutdown, 11 | // respectively. WSAStartup() increments an internal Windows library reference 12 | // count which is decremented by WSACleanup(). When the reference count is just 13 | // one, calling WSACleanup() frees all resources and all DLLs are unloaded. 14 | // This is an expensive operation. To avoid this, an application can manually 15 | // call WSAStartup() so resources will not be freed when the last database 16 | // connection is closed. 17 | 18 | void R_init_mypackage(DllInfo *info) { 19 | #ifdef _WIN32 20 | WSAStartup(MAKEWORD(1, 0), NULL); 21 | #endif 22 | } 23 | 24 | void R_unload_mylib(DllInfo *info) { 25 | #ifdef _WIN32 26 | WSACleanup(); 27 | #endif 28 | } 29 | -------------------------------------------------------------------------------- /src/RPostgres_types.h: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | 3 | #ifndef __RPOSTGRES_TYPES__ 4 | #define __RPOSTGRES_TYPES__ 5 | 6 | #include "DbConnection.h" 7 | #include "DbResult.h" 8 | 9 | namespace cpp11 { 10 | 11 | template 12 | enable_if_t, DbConnection*>::value, decay_t> as_cpp(SEXP from) { 13 | DbConnectionPtr* connection = (DbConnectionPtr*)(R_ExternalPtrAddr(from)); 14 | if (!connection) 15 | stop("Invalid connection"); 16 | return connection->get(); 17 | } 18 | 19 | template 20 | enable_if_t, DbResult*>::value, decay_t> as_cpp(SEXP from) { 21 | DbResult* result = (DbResult*)(R_ExternalPtrAddr(from)); 22 | if (!result) 23 | stop("Invalid result set"); 24 | return result; 25 | } 26 | 27 | } 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /src/custom.cmake: -------------------------------------------------------------------------------- 1 | target_include_directories(RPostgres PUBLIC 2 | "/usr/include/postgresql" 3 | "vendor" 4 | ) 5 | 6 | target_compile_definitions(RPostgres PUBLIC 7 | "RCPP_DEFAULT_INCLUDE_CALL=false" 8 | "RCPP_USING_UTF8_ERROR_STRING" 9 | "BOOST_NO_AUTO_PTR" 10 | ) 11 | -------------------------------------------------------------------------------- /src/encode.h: -------------------------------------------------------------------------------- 1 | #ifndef __RPOSTGRES_ENCODE__ 2 | #define __RPOSTGRES_ENCODE__ 3 | 4 | // Defined in encode.cpp ------------------------------------------------------- 5 | 6 | void escape_in_buffer(const char* string, std::string& buffer); 7 | void encode_in_buffer(cpp11::sexp x, int i, std::string& buffer); 8 | void encode_row_in_buffer(cpp11::list x, int i, std::string& buffer, 9 | std::string fieldDelim = "\t", 10 | std::string lineDelim = "\n"); 11 | std::string encode_data_frame(cpp11::list x); 12 | 13 | #endif 14 | -------------------------------------------------------------------------------- /src/encrypt.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | 3 | 4 | [[cpp11::register]] 5 | std::string encrypt_password(cpp11::r_string password, cpp11::r_string user) { 6 | const auto pass = static_cast(password); 7 | const auto u = static_cast(user); 8 | 9 | const char* encrypted = PQencryptPassword(pass.c_str(), u.c_str()); 10 | 11 | return encrypted; 12 | } 13 | -------------------------------------------------------------------------------- /src/integer64.h: -------------------------------------------------------------------------------- 1 | #ifndef RPOSTGRES_INTEGER64_H 2 | #define RPOSTGRES_INTEGER64_H 3 | 4 | #define INT64SXP REALSXP 5 | 6 | #define NA_INTEGER64 (0x8000000000000000) 7 | 8 | inline int64_t* INTEGER64(SEXP x) { 9 | return reinterpret_cast(REAL(x)); 10 | } 11 | 12 | #endif // RPOSTGRES_INTEGER64_H 13 | -------------------------------------------------------------------------------- /src/logging.cpp: -------------------------------------------------------------------------------- 1 | #include "pch.h" 2 | #include 3 | 4 | 5 | [[cpp11::register]] 6 | void init_logging(const std::string& log_level) { 7 | plog::init_r(log_level); 8 | } 9 | -------------------------------------------------------------------------------- /src/pch.h: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | #include 6 | 7 | // Temporary fix for false positive in gcc-12 (fixed in gcc-13) 8 | #if __GNUC__ == 12 9 | /*IGNORE*/ #pragma GCC diagnostic push 10 | /*IGNORE*/ #pragma GCC diagnostic ignored "-Wuse-after-free" 11 | #endif 12 | 13 | -------------------------------------------------------------------------------- /src/vendor/boost/call_traits.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 2 | // Use, modification and distribution are subject to the Boost Software License, 3 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt). 5 | // 6 | // See http://www.boost.org/libs/utility for most recent version including documentation. 7 | 8 | // See boost/detail/call_traits.hpp 9 | // for full copyright notices. 10 | 11 | #ifndef BOOST_CALL_TRAITS_HPP 12 | #define BOOST_CALL_TRAITS_HPP 13 | 14 | #ifndef BOOST_CONFIG_HPP 15 | #include 16 | #endif 17 | 18 | #include 19 | 20 | #endif // BOOST_CALL_TRAITS_HPP 21 | -------------------------------------------------------------------------------- /src/vendor/boost/checked_delete.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_CHECKED_DELETE_HPP 10 | #define BOOST_CHECKED_DELETE_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/checked_delete.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/compressed_pair.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 2 | // Use, modification and distribution are subject to the Boost Software License, 3 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt). 5 | // 6 | // See http://www.boost.org/libs/utility for most recent version including documentation. 7 | 8 | // See boost/detail/compressed_pair.hpp 9 | // for full copyright notices. 10 | 11 | #ifndef BOOST_COMPRESSED_PAIR_HPP 12 | #define BOOST_COMPRESSED_PAIR_HPP 13 | 14 | #ifndef BOOST_CONFIG_HPP 15 | #include 16 | #endif 17 | 18 | #include 19 | 20 | #endif // BOOST_COMPRESSED_PAIR_HPP 21 | -------------------------------------------------------------------------------- /src/vendor/boost/concept/detail/backward_compatibility.hpp: -------------------------------------------------------------------------------- 1 | // Copyright David Abrahams 2009. Distributed under the Boost 2 | // Software License, Version 1.0. (See accompanying 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 4 | #ifndef BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP 5 | # define BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP 6 | 7 | namespace boost 8 | { 9 | namespace concepts {} 10 | 11 | # if defined(BOOST_HAS_CONCEPTS) && !defined(BOOST_CONCEPT_NO_BACKWARD_KEYWORD) 12 | namespace concept = concepts; 13 | # endif 14 | } // namespace boost::concept 15 | 16 | #endif // BOOST_CONCEPT_BACKWARD_COMPATIBILITY_DWA200968_HPP 17 | -------------------------------------------------------------------------------- /src/vendor/boost/concept/detail/concept_undef.hpp: -------------------------------------------------------------------------------- 1 | // Copyright David Abrahams 2006. Distributed under the Boost 2 | // Software License, Version 1.0. (See accompanying 3 | // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 4 | # undef BOOST_concept_typename 5 | # undef BOOST_concept 6 | -------------------------------------------------------------------------------- /src/vendor/boost/config/abi/borland_suffix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | # pragma option pop 7 | #pragma nopushoptwarn 8 | 9 | 10 | 11 | 12 | 13 | -------------------------------------------------------------------------------- /src/vendor/boost/config/abi/msvc_prefix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // 7 | // Boost binaries are built with the compiler's default ABI settings, 8 | // if the user changes their default alignment in the VS IDE then their 9 | // code will no longer be binary compatible with the bjam built binaries 10 | // unless this header is included to force Boost code into a consistent ABI. 11 | // 12 | // Note that inclusion of this header is only necessary for libraries with 13 | // separate source, header only libraries DO NOT need this as long as all 14 | // translation units are built with the same options. 15 | // 16 | #if defined(_M_X64) 17 | # pragma pack(push,16) 18 | #else 19 | # pragma pack(push,8) 20 | #endif 21 | 22 | 23 | -------------------------------------------------------------------------------- /src/vendor/boost/config/abi/msvc_suffix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #pragma pack(pop) 7 | 8 | 9 | -------------------------------------------------------------------------------- /src/vendor/boost/config/abi_prefix.hpp: -------------------------------------------------------------------------------- 1 | // abi_prefix header -------------------------------------------------------// 2 | 3 | // (c) Copyright John Maddock 2003 4 | 5 | // Use, modification and distribution are subject to the Boost Software License, 6 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt). 8 | 9 | #ifndef BOOST_CONFIG_ABI_PREFIX_HPP 10 | # define BOOST_CONFIG_ABI_PREFIX_HPP 11 | #else 12 | # error double inclusion of header boost/config/abi_prefix.hpp is an error 13 | #endif 14 | 15 | #include 16 | 17 | // this must occur after all other includes and before any code appears: 18 | #ifdef BOOST_HAS_ABI_HEADERS 19 | # include BOOST_ABI_PREFIX 20 | #endif 21 | 22 | #if defined( BOOST_BORLANDC ) 23 | #pragma nopushoptwarn 24 | #endif 25 | 26 | -------------------------------------------------------------------------------- /src/vendor/boost/config/abi_suffix.hpp: -------------------------------------------------------------------------------- 1 | // abi_sufffix header -------------------------------------------------------// 2 | 3 | // (c) Copyright John Maddock 2003 4 | 5 | // Use, modification and distribution are subject to the Boost Software License, 6 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt). 8 | 9 | // This header should be #included AFTER code that was preceded by a #include 10 | // . 11 | 12 | #ifndef BOOST_CONFIG_ABI_PREFIX_HPP 13 | # error Header boost/config/abi_suffix.hpp must only be used after boost/config/abi_prefix.hpp 14 | #else 15 | # undef BOOST_CONFIG_ABI_PREFIX_HPP 16 | #endif 17 | 18 | // the suffix header occurs after all of our code: 19 | #ifdef BOOST_HAS_ABI_HEADERS 20 | # include BOOST_ABI_SUFFIX 21 | #endif 22 | 23 | #if defined( BOOST_BORLANDC ) 24 | #pragma nopushoptwarn 25 | #endif 26 | -------------------------------------------------------------------------------- /src/vendor/boost/config/compiler/compaq_cxx.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Tru64 C++ compiler setup (now HP): 9 | 10 | #define BOOST_COMPILER "HP Tru64 C++ " BOOST_STRINGIZE(__DECCXX_VER) 11 | 12 | #include 13 | 14 | // 15 | // versions check: 16 | // Nothing to do here? 17 | 18 | 19 | 20 | -------------------------------------------------------------------------------- /src/vendor/boost/config/compiler/diab.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Brian Kuhl 2016. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // Check this is a recent EDG based compiler, otherwise we don't support it here: 7 | 8 | 9 | #ifndef __EDG_VERSION__ 10 | # error "Unknown Diab compiler version - please run the configure tests and report the results" 11 | #endif 12 | 13 | #include "boost/config/compiler/common_edg.hpp" 14 | 15 | #define BOOST_NO_TWO_PHASE_NAME_LOOKUP 16 | #define BOOST_BUGGY_INTEGRAL_CONSTANT_EXPRESSIONS 17 | 18 | #define BOOST_MPL_CFG_NO_HAS_XXX_TEMPLATE 19 | #define BOOST_LOG_NO_MEMBER_TEMPLATE_FRIENDS 20 | #define BOOST_REGEX_NO_EXTERNAL_TEMPLATES 21 | 22 | #define BOOST_NO_CXX11_HDR_INITIALIZER_LIST 23 | #define BOOST_NO_CXX11_HDR_CODECVT 24 | #define BOOST_NO_CXX11_NUMERIC_LIMITS 25 | 26 | #define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__) 27 | -------------------------------------------------------------------------------- /src/vendor/boost/config/compiler/greenhills.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Greenhills C++ compiler setup: 9 | 10 | #define BOOST_COMPILER "Greenhills C++ version " BOOST_STRINGIZE(__ghs) 11 | 12 | #include 13 | 14 | // 15 | // versions check: 16 | // we don't support Greenhills prior to version 0: 17 | #if __ghs < 0 18 | # error "Compiler not supported or configured - please reconfigure" 19 | #endif 20 | // 21 | // last known and checked version is 0: 22 | #if (__ghs > 0) 23 | # if defined(BOOST_ASSERT_CONFIG) 24 | # error "boost: Unknown compiler version - please run the configure tests and report the results" 25 | # endif 26 | #endif 27 | 28 | 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/compiler/pgi.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Noel Belcourt 2007. 2 | // Copyright 2017, NVIDIA CORPORATION. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // PGI C++ compiler setup: 10 | 11 | #define BOOST_COMPILER_VERSION __PGIC__##__PGIC_MINOR__ 12 | #define BOOST_COMPILER "PGI compiler version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION) 13 | 14 | // PGI is mostly GNU compatible. So start with that. 15 | #include 16 | 17 | // Now adjust for things that are different. 18 | 19 | // __float128 is a typedef, not a distinct type. 20 | #undef BOOST_HAS_FLOAT128 21 | 22 | // __int128 is not supported. 23 | #undef BOOST_HAS_INT128 24 | -------------------------------------------------------------------------------- /src/vendor/boost/config/compiler/sgi_mipspro.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // SGI C++ compiler setup: 9 | 10 | #define BOOST_COMPILER "SGI Irix compiler version " BOOST_STRINGIZE(_COMPILER_VERSION) 11 | 12 | #include 13 | 14 | // 15 | // Threading support: 16 | // Turn this on unconditionally here, it will get turned off again later 17 | // if no threading API is detected. 18 | // 19 | #define BOOST_HAS_THREADS 20 | #define BOOST_NO_TWO_PHASE_NAME_LOOKUP 21 | 22 | #undef BOOST_NO_SWPRINTF 23 | #undef BOOST_DEDUCED_TYPENAME 24 | 25 | // 26 | // version check: 27 | // probably nothing to do here? 28 | 29 | 30 | -------------------------------------------------------------------------------- /src/vendor/boost/config/header_deprecated.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 2 | #define BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 3 | 4 | // Copyright 2017 Peter Dimov. 5 | // 6 | // Distributed under the Boost Software License, Version 1.0. 7 | // 8 | // See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt 10 | // 11 | // BOOST_HEADER_DEPRECATED("") 12 | // 13 | // Expands to the equivalent of 14 | // BOOST_PRAGMA_MESSAGE("This header is deprecated. Use instead.") 15 | // 16 | // Note that this header is C compatible. 17 | 18 | #include 19 | 20 | #if defined(BOOST_ALLOW_DEPRECATED_HEADERS) || defined(BOOST_ALLOW_DEPRECATED) 21 | # define BOOST_HEADER_DEPRECATED(a) 22 | #else 23 | # define BOOST_HEADER_DEPRECATED(a) BOOST_PRAGMA_MESSAGE("This header is deprecated. Use " a " instead.") 24 | #endif 25 | 26 | #endif // BOOST_CONFIG_HEADER_DEPRECATED_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/config/no_tr1/cmath.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2008. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/cmath is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_CMATH 14 | # define BOOST_CONFIG_CMATH 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_CMATH_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_CMATH_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_CMATH_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/no_tr1/complex.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/complex is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_COMPLEX 14 | # define BOOST_CONFIG_COMPLEX 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_COMPLEX_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_COMPLEX_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_COMPLEX_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/no_tr1/functional.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/functional is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_FUNCTIONAL 14 | # define BOOST_CONFIG_FUNCTIONAL 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_FUNCTIONAL_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/no_tr1/memory.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/memory is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_MEMORY 14 | # define BOOST_CONFIG_MEMORY 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_MEMORY_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_MEMORY_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_MEMORY_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/no_tr1/utility.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | // 6 | // The aim of this header is just to include but to do 7 | // so in a way that does not result in recursive inclusion of 8 | // the Boost TR1 components if boost/tr1/tr1/utility is in the 9 | // include search path. We have to do this to avoid circular 10 | // dependencies: 11 | // 12 | 13 | #ifndef BOOST_CONFIG_UTILITY 14 | # define BOOST_CONFIG_UTILITY 15 | 16 | # ifndef BOOST_TR1_NO_RECURSION 17 | # define BOOST_TR1_NO_RECURSION 18 | # define BOOST_CONFIG_NO_UTILITY_RECURSION 19 | # endif 20 | 21 | # include 22 | 23 | # ifdef BOOST_CONFIG_NO_UTILITY_RECURSION 24 | # undef BOOST_TR1_NO_RECURSION 25 | # undef BOOST_CONFIG_NO_UTILITY_RECURSION 26 | # endif 27 | 28 | #endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/aix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // IBM/Aix specific config options: 9 | 10 | #define BOOST_PLATFORM "IBM Aix" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_NL_TYPES_H 14 | #define BOOST_HAS_NANOSLEEP 15 | #define BOOST_HAS_CLOCK_GETTIME 16 | 17 | // This needs support in "boost/cstdint.hpp" exactly like FreeBSD. 18 | // This platform has header named which includes all 19 | // the things needed. 20 | #define BOOST_HAS_STDINT_H 21 | 22 | // Threading API's: 23 | #define BOOST_HAS_PTHREADS 24 | #define BOOST_HAS_PTHREAD_DELAY_NP 25 | #define BOOST_HAS_SCHED_YIELD 26 | //#define BOOST_HAS_PTHREAD_YIELD 27 | 28 | // boilerplate code: 29 | #include 30 | 31 | 32 | 33 | 34 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/amigaos.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2002. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | #define BOOST_PLATFORM "AmigaOS" 9 | 10 | #define BOOST_DISABLE_THREADS 11 | #define BOOST_NO_CWCHAR 12 | #define BOOST_NO_STD_WSTRING 13 | #define BOOST_NO_INTRINSIC_WCHAR_T 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/beos.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // BeOS specific config options: 9 | 10 | #define BOOST_PLATFORM "BeOS" 11 | 12 | #define BOOST_NO_CWCHAR 13 | #define BOOST_NO_CWCTYPE 14 | #define BOOST_HAS_UNISTD_H 15 | 16 | #define BOOST_HAS_BETHREADS 17 | 18 | #ifndef BOOST_DISABLE_THREADS 19 | # define BOOST_HAS_THREADS 20 | #endif 21 | 22 | // boilerplate code: 23 | #include 24 | 25 | 26 | 27 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/cloudabi.hpp: -------------------------------------------------------------------------------- 1 | // Copyright Nuxi, https://nuxi.nl/ 2015. 2 | // Distributed under the Boost Software License, Version 1.0. 3 | // (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #define BOOST_PLATFORM "CloudABI" 7 | 8 | #define BOOST_HAS_DIRENT_H 9 | #define BOOST_HAS_STDINT_H 10 | #define BOOST_HAS_UNISTD_H 11 | 12 | #define BOOST_HAS_CLOCK_GETTIME 13 | #define BOOST_HAS_EXPM1 14 | #define BOOST_HAS_GETTIMEOFDAY 15 | #define BOOST_HAS_LOG1P 16 | #define BOOST_HAS_NANOSLEEP 17 | #define BOOST_HAS_PTHREADS 18 | #define BOOST_HAS_SCHED_YIELD 19 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/cray.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2011. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // SGI Irix specific config options: 10 | 11 | #define BOOST_PLATFORM "Cray" 12 | 13 | // boilerplate code: 14 | #define BOOST_HAS_UNISTD_H 15 | #include 16 | 17 | 18 | 19 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/haiku.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Jessica Hamilton 2014. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // Haiku specific config options: 9 | 10 | #define BOOST_PLATFORM "Haiku" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_STDINT_H 14 | 15 | #ifndef BOOST_DISABLE_THREADS 16 | # define BOOST_HAS_THREADS 17 | #endif 18 | 19 | #define BOOST_NO_CXX11_HDR_TYPE_TRAITS 20 | #define BOOST_NO_CXX11_ATOMIC_SMART_PTR 21 | #define BOOST_NO_CXX11_STATIC_ASSERT 22 | #define BOOST_NO_CXX11_VARIADIC_MACROS 23 | 24 | // 25 | // thread API's not auto detected: 26 | // 27 | #define BOOST_HAS_SCHED_YIELD 28 | #define BOOST_HAS_GETTIMEOFDAY 29 | 30 | // boilerplate code: 31 | #include 32 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/irix.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // (C) Copyright Jens Maurer 2003. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | 8 | // See http://www.boost.org for most recent version. 9 | 10 | // SGI Irix specific config options: 11 | 12 | #define BOOST_PLATFORM "SGI Irix" 13 | 14 | #define BOOST_NO_SWPRINTF 15 | // 16 | // these are not auto detected by POSIX feature tests: 17 | // 18 | #define BOOST_HAS_GETTIMEOFDAY 19 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 20 | 21 | #ifdef __GNUC__ 22 | // GNU C on IRIX does not support threads (checked up to gcc 3.3) 23 | # define BOOST_DISABLE_THREADS 24 | #endif 25 | 26 | // boilerplate code: 27 | #define BOOST_HAS_UNISTD_H 28 | #include 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/qnxnto.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Jim Douglas 2005. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // QNX specific config options: 9 | 10 | #define BOOST_PLATFORM "QNX" 11 | 12 | #define BOOST_HAS_UNISTD_H 13 | #include 14 | 15 | // QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h 16 | // or log1p and expm1: 17 | #undef BOOST_HAS_NL_TYPES_H 18 | #undef BOOST_HAS_LOG1P 19 | #undef BOOST_HAS_EXPM1 20 | 21 | #define BOOST_HAS_PTHREADS 22 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 23 | 24 | #define BOOST_HAS_GETTIMEOFDAY 25 | #define BOOST_HAS_CLOCK_GETTIME 26 | #define BOOST_HAS_NANOSLEEP 27 | 28 | 29 | 30 | 31 | 32 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/solaris.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2001 - 2003. 2 | // (C) Copyright Jens Maurer 2003. 3 | // Use, modification and distribution are subject to the 4 | // Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // sun specific config options: 10 | 11 | #define BOOST_PLATFORM "Sun Solaris" 12 | 13 | #define BOOST_HAS_GETTIMEOFDAY 14 | 15 | // boilerplate code: 16 | #define BOOST_HAS_UNISTD_H 17 | #include 18 | 19 | // 20 | // pthreads don't actually work with gcc unless _PTHREADS is defined: 21 | // 22 | #if defined(__GNUC__) && defined(_POSIX_THREADS) && !defined(_PTHREADS) 23 | # undef BOOST_HAS_PTHREADS 24 | #endif 25 | 26 | #define BOOST_HAS_STDINT_H 27 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 28 | #define BOOST_HAS_LOG1P 29 | #define BOOST_HAS_EXPM1 30 | 31 | 32 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/vms.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Artyom Beilis 2010. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #ifndef BOOST_CONFIG_PLATFORM_VMS_HPP 7 | #define BOOST_CONFIG_PLATFORM_VMS_HPP 8 | 9 | #define BOOST_PLATFORM "OpenVMS" 10 | 11 | #undef BOOST_HAS_STDINT_H 12 | #define BOOST_HAS_UNISTD_H 13 | #define BOOST_HAS_NL_TYPES_H 14 | #define BOOST_HAS_GETTIMEOFDAY 15 | #define BOOST_HAS_DIRENT_H 16 | #define BOOST_HAS_PTHREADS 17 | #define BOOST_HAS_NANOSLEEP 18 | #define BOOST_HAS_CLOCK_GETTIME 19 | #define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 20 | #define BOOST_HAS_LOG1P 21 | #define BOOST_HAS_EXPM1 22 | #define BOOST_HAS_THREADS 23 | #undef BOOST_HAS_SCHED_YIELD 24 | 25 | #endif 26 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/wasm.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2020. 2 | // Use, modification and distribution are subject to the 3 | // Boost Software License, Version 1.0. (See accompanying file 4 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See http://www.boost.org for most recent version. 7 | 8 | // WASM specific config options: 9 | 10 | #define BOOST_PLATFORM "Wasm" 11 | 12 | #ifdef __has_include 13 | #if __has_include() 14 | # define BOOST_HAS_UNISTD_H 15 | #endif 16 | #endif 17 | 18 | // boilerplate code: 19 | #include 20 | // 21 | // fenv lacks the C++11 macros: 22 | // 23 | #define BOOST_NO_FENV_H 24 | -------------------------------------------------------------------------------- /src/vendor/boost/config/platform/zos.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2017 Dynatrace 2 | // 3 | // Distributed under the Boost Software License, Version 1.0. 4 | // See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt 6 | 7 | // See http://www.boost.org for most recent version. 8 | 9 | // Platform setup for IBM z/OS. 10 | 11 | #define BOOST_PLATFORM "IBM z/OS" 12 | 13 | #include // For __UU, __C99, __TR1, ... 14 | 15 | #if defined(__UU) 16 | # define BOOST_HAS_GETTIMEOFDAY 17 | #endif 18 | 19 | #if defined(_OPEN_THREADS) || defined(__SUSV3_THR) 20 | # define BOOST_HAS_PTHREADS 21 | # define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE 22 | # define BOOST_HAS_THREADS 23 | #endif 24 | 25 | #if defined(__SUSV3) || defined(__SUSV3_THR) 26 | # define BOOST_HAS_SCHED_YIELD 27 | #endif 28 | 29 | #define BOOST_HAS_SIGACTION 30 | #define BOOST_HAS_UNISTD_H 31 | #define BOOST_HAS_DIRENT_H 32 | #define BOOST_HAS_NL_TYPES_H 33 | -------------------------------------------------------------------------------- /src/vendor/boost/container/detail/addressof.hpp: -------------------------------------------------------------------------------- 1 | ////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2014-2015. Distributed under the Boost 4 | // Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | // 7 | // See http://www.boost.org/libs/container for documentation. 8 | // 9 | ////////////////////////////////////////////////////////////////////////////// 10 | #ifndef BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP 11 | #define BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP 12 | 13 | #ifndef BOOST_CONFIG_HPP 14 | # include 15 | #endif 16 | 17 | #if defined(BOOST_HAS_PRAGMA_ONCE) 18 | # pragma once 19 | #endif 20 | 21 | #include 22 | 23 | namespace boost { 24 | namespace container { 25 | namespace dtl { 26 | 27 | using boost::move_detail::addressof; 28 | 29 | } //namespace dtl { 30 | } //namespace container { 31 | } //namespace boost { 32 | 33 | #endif //#ifndef BOOST_CONTAINER_DETAIL_ADDRESSOF_HPP 34 | -------------------------------------------------------------------------------- /src/vendor/boost/container/detail/config_end.hpp: -------------------------------------------------------------------------------- 1 | ////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost 4 | // Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | // 7 | // See http://www.boost.org/libs/container for documentation. 8 | // 9 | ////////////////////////////////////////////////////////////////////////////// 10 | #if defined BOOST_MSVC 11 | #pragma warning (pop) 12 | #endif 13 | 14 | #if defined(BOOST_GCC) && (BOOST_GCC >= 40600) 15 | #pragma GCC diagnostic pop 16 | #endif 17 | -------------------------------------------------------------------------------- /src/vendor/boost/core/is_same.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED 2 | #define BOOST_CORE_IS_SAME_HPP_INCLUDED 3 | 4 | // MS compatible compilers support #pragma once 5 | 6 | #if defined(_MSC_VER) && (_MSC_VER >= 1020) 7 | # pragma once 8 | #endif 9 | 10 | // is_same::value is true when T1 == T2 11 | // 12 | // Copyright 2014 Peter Dimov 13 | // 14 | // Distributed under the Boost Software License, Version 1.0. 15 | // See accompanying file LICENSE_1_0.txt or copy at 16 | // http://www.boost.org/LICENSE_1_0.txt 17 | 18 | #include 19 | 20 | namespace boost 21 | { 22 | 23 | namespace core 24 | { 25 | 26 | template< class T1, class T2 > struct is_same 27 | { 28 | BOOST_STATIC_CONSTANT( bool, value = false ); 29 | }; 30 | 31 | template< class T > struct is_same< T, T > 32 | { 33 | BOOST_STATIC_CONSTANT( bool, value = true ); 34 | }; 35 | 36 | } // namespace core 37 | 38 | } // namespace boost 39 | 40 | #endif // #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED 41 | -------------------------------------------------------------------------------- /src/vendor/boost/core/use_default.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2019 Glen Joseph Fernandes 3 | (glenjofe@gmail.com) 4 | 5 | Distributed under the Boost Software License, Version 1.0. 6 | (http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | #ifndef BOOST_CORE_USE_DEFAULT_HPP 9 | #define BOOST_CORE_USE_DEFAULT_HPP 10 | 11 | namespace boost { 12 | 13 | struct use_default { }; 14 | 15 | } /* boost */ 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/detail/workaround.hpp: -------------------------------------------------------------------------------- 1 | // Copyright David Abrahams 2002. 2 | // Distributed under the Boost Software License, Version 1.0. (See 3 | // accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | #ifndef BOOST_WORKAROUND_DWA2002126_HPP 6 | #define BOOST_WORKAROUND_DWA2002126_HPP 7 | 8 | #include 9 | 10 | #endif // BOOST_WORKAROUND_DWA2002126_HPP 11 | -------------------------------------------------------------------------------- /src/vendor/boost/intrusive/detail/config_end.hpp: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2006-2013 4 | // 5 | // Distributed under the Boost Software License, Version 1.0. 6 | // (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // See http://www.boost.org/libs/intrusive for documentation. 10 | // 11 | ///////////////////////////////////////////////////////////////////////////// 12 | 13 | #if defined BOOST_MSVC 14 | #pragma warning (pop) 15 | #endif 16 | -------------------------------------------------------------------------------- /src/vendor/boost/intrusive/detail/minimal_pair_header.hpp: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2014-2015 4 | // 5 | // Distributed under the Boost Software License, Version 1.0. 6 | // (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // See http://www.boost.org/libs/intrusive for documentation. 10 | // 11 | ///////////////////////////////////////////////////////////////////////////// 12 | #ifndef BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP 13 | #define BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP 14 | # 15 | #if defined(BOOST_HAS_PRAGMA_ONCE) 16 | # pragma once 17 | #endif 18 | # 19 | #ifndef BOOST_CONFIG_HPP 20 | # include 21 | #endif 22 | # 23 | #//Try to avoid including , as it's quite big in C++11 24 | #if defined(BOOST_GNU_STDLIB) 25 | # include 26 | #else 27 | # include //Fallback 28 | #endif 29 | # 30 | #endif //BOOST_INTRUSIVE_DETAIL_MINIMAL_PAIR_HEADER_HPP 31 | -------------------------------------------------------------------------------- /src/vendor/boost/intrusive/detail/node_holder.hpp: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2014-2014 4 | // 5 | // Distributed under the Boost Software License, Version 1.0. 6 | // (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // See http://www.boost.org/libs/intrusive for documentation. 10 | // 11 | ///////////////////////////////////////////////////////////////////////////// 12 | 13 | #ifndef BOOST_INTRUSIVE_DETAIL_NODE_HOLDER_HPP 14 | #define BOOST_INTRUSIVE_DETAIL_NODE_HOLDER_HPP 15 | 16 | #ifndef BOOST_CONFIG_HPP 17 | # include 18 | #endif 19 | 20 | #if defined(BOOST_HAS_PRAGMA_ONCE) 21 | # pragma once 22 | #endif 23 | 24 | namespace boost { 25 | namespace intrusive { 26 | 27 | template 28 | struct node_holder 29 | : public Node 30 | {}; 31 | 32 | } //namespace intrusive{ 33 | } //namespace boost{ 34 | 35 | #endif //BOOST_INTRUSIVE_DETAIL_NODE_HOLDER_HPP 36 | -------------------------------------------------------------------------------- /src/vendor/boost/intrusive/detail/reverse_iterator.hpp: -------------------------------------------------------------------------------- 1 | ///////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2014-2014 4 | // 5 | // Distributed under the Boost Software License, Version 1.0. 6 | // (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // See http://www.boost.org/libs/intrusive for documentation. 10 | // 11 | ///////////////////////////////////////////////////////////////////////////// 12 | 13 | #ifndef BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP 14 | #define BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP 15 | 16 | #include 17 | 18 | namespace boost { 19 | namespace intrusive { 20 | 21 | using boost::movelib::reverse_iterator; 22 | using boost::movelib::make_reverse_iterator; 23 | 24 | } //namespace intrusive { 25 | } //namespace boost { 26 | 27 | 28 | #endif //BOOST_INTRUSIVE_DETAIL_REVERSE_ITERATOR_HPP 29 | -------------------------------------------------------------------------------- /src/vendor/boost/is_placeholder.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_IS_PLACEHOLDER_HPP_INCLUDED 2 | #define BOOST_IS_PLACEHOLDER_HPP_INCLUDED 3 | 4 | // MS compatible compilers support #pragma once 5 | 6 | #if defined( _MSC_VER ) && ( _MSC_VER >= 1020 ) 7 | # pragma once 8 | #endif 9 | 10 | 11 | // is_placeholder.hpp - TR1 is_placeholder metafunction 12 | // 13 | // Copyright (c) 2006 Peter Dimov 14 | // 15 | // Distributed under the Boost Software License, Version 1.0. 16 | // 17 | // See accompanying file LICENSE_1_0.txt or copy at 18 | // http://www.boost.org/LICENSE_1_0.txt 19 | 20 | 21 | namespace boost 22 | { 23 | 24 | template< class T > struct is_placeholder 25 | { 26 | enum _vt { value = 0 }; 27 | }; 28 | 29 | } // namespace boost 30 | 31 | #endif // #ifndef BOOST_IS_PLACEHOLDER_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /src/vendor/boost/iterator/detail/config_undef.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Thomas Witt 2002. 2 | // Distributed under the Boost Software License, Version 1.0. (See 3 | // accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // no include guard multiple inclusion intended 7 | 8 | // 9 | // This is a temporary workaround until the bulk of this is 10 | // available in boost config. 11 | // 23/02/03 thw 12 | // 13 | 14 | #undef BOOST_NO_IS_CONVERTIBLE 15 | #undef BOOST_NO_IS_CONVERTIBLE_TEMPLATE 16 | #undef BOOST_NO_STRICT_ITERATOR_INTEROPERABILITY 17 | #undef BOOST_NO_LVALUE_RETURN_DETECTION 18 | #undef BOOST_NO_ONE_WAY_ITERATOR_INTEROP 19 | 20 | #ifdef BOOST_ITERATOR_CONFIG_DEF 21 | # undef BOOST_ITERATOR_CONFIG_DEF 22 | #else 23 | # error missing or nested #include config_def 24 | #endif 25 | -------------------------------------------------------------------------------- /src/vendor/boost/move/detail/config_end.hpp: -------------------------------------------------------------------------------- 1 | ////////////////////////////////////////////////////////////////////////////// 2 | // 3 | // (C) Copyright Ion Gaztanaga 2012-2012. Distributed under the Boost 4 | // Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 | // 7 | // See http://www.boost.org/libs/move for documentation. 8 | // 9 | ////////////////////////////////////////////////////////////////////////////// 10 | #if defined BOOST_MSVC 11 | # pragma warning (pop) 12 | #endif 13 | -------------------------------------------------------------------------------- /src/vendor/boost/move/detail/placement_new.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP 2 | #define BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP 3 | /////////////////////////////////////////////////////////////////////////////// 4 | // 5 | // (C) Copyright Ion Gaztanaga 2014-2015. Distributed under the Boost 6 | // Software License, Version 1.0. (See accompanying file 7 | // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // See http://www.boost.org/libs/container for documentation. 10 | // 11 | /////////////////////////////////////////////////////////////////////////////// 12 | 13 | #ifndef BOOST_CONFIG_HPP 14 | # include 15 | #endif 16 | 17 | #if defined(BOOST_HAS_PRAGMA_ONCE) 18 | # pragma once 19 | #endif 20 | 21 | struct boost_move_new_t{}; 22 | 23 | //avoid including 24 | inline void *operator new(std::size_t, void *p, boost_move_new_t) 25 | { return p; } 26 | 27 | inline void operator delete(void *, void *, boost_move_new_t) 28 | {} 29 | 30 | #endif //BOOST_MOVE_DETAIL_PLACEMENT_NEW_HPP 31 | -------------------------------------------------------------------------------- /src/vendor/boost/move/detail/std_ns_end.hpp: -------------------------------------------------------------------------------- 1 | #////////////////////////////////////////////////////////////////////////////// 2 | #// 3 | #// (C) Copyright Ion Gaztanaga 2015-2015. 4 | #// Distributed under the Boost Software License, Version 1.0. 5 | #// (See accompanying file LICENSE_1_0.txt or copy at 6 | #// http://www.boost.org/LICENSE_1_0.txt) 7 | #// 8 | #// See http://www.boost.org/libs/move for documentation. 9 | #// 10 | #////////////////////////////////////////////////////////////////////////////// 11 | #ifdef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH 12 | #pragma GCC diagnostic pop 13 | #undef BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH 14 | #elif defined(_MSC_VER) && (_MSC_VER >= 1915) 15 | #pragma warning (pop) 16 | #endif //BOOST_MOVE_STD_NS_GCC_DIAGNOSTIC_PUSH 17 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/always.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_ALWAYS_HPP_INCLUDED 3 | #define BOOST_MPL_ALWAYS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | namespace boost { namespace mpl { 22 | 23 | template< typename Value > struct always 24 | { 25 | template< 26 | BOOST_MPL_PP_DEFAULT_PARAMS(BOOST_MPL_LIMIT_METAFUNCTION_ARITY, typename T, na) 27 | > 28 | struct apply 29 | { 30 | typedef Value type; 31 | }; 32 | }; 33 | 34 | BOOST_MPL_AUX_ARITY_SPEC(0, always) 35 | 36 | }} 37 | 38 | #endif // BOOST_MPL_ALWAYS_HPP_INCLUDED 39 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/arg_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_ARG_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_ARG_FWD_HPP_INCLUDED 4 | 5 | // Copyright Peter Dimov 2001-2002 6 | // Copyright Aleksey Gurtovoy 2001-2004 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | #include 20 | 21 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 22 | 23 | template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct arg; 24 | 25 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 26 | BOOST_MPL_AUX_ADL_BARRIER_DECL(arg) 27 | 28 | #endif // BOOST_MPL_ARG_FWD_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/arg_typedef.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ 21 | || BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) 22 | 23 | # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) typedef T name; 24 | 25 | #else 26 | 27 | # define BOOST_MPL_AUX_ARG_TYPEDEF(T, name) /**/ 28 | 29 | #endif 30 | 31 | #endif // BOOST_MPL_AUX_ARG_TYPEDEF_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/common_name_wknd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if BOOST_WORKAROUND(BOOST_BORLANDC, < 0x561) 20 | // agurt, 12/nov/02: to suppress the bogus "Cannot have both a template class 21 | // and function named 'xxx'" diagnostic 22 | # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) \ 23 | namespace name_##wknd { \ 24 | template< typename > void name(); \ 25 | } \ 26 | /**/ 27 | 28 | #else 29 | 30 | # define BOOST_MPL_AUX_COMMON_NAME_WKND(name) /**/ 31 | 32 | #endif // BOOST_BORLANDC 33 | 34 | #endif // BOOST_MPL_AUX_COMMON_NAME_WKND_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/arrays.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2003-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if !defined(BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES) \ 21 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 22 | && ( BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) \ 23 | || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 24 | ) 25 | 26 | # define BOOST_MPL_CFG_NO_DEPENDENT_ARRAY_TYPES 27 | 28 | #endif 29 | 30 | #endif // BOOST_MPL_AUX_CONFIG_ARRAYS_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/bcc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2008 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date: 2004-09-02 10:41:37 -0500 (Thu, 02 Sep 2004) $ 15 | // $Revision: 24874 $ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_BCC590_WORKAROUNDS) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && BOOST_WORKAROUND(BOOST_BORLANDC, >= 0x590) \ 22 | && BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) 23 | 24 | # define BOOST_MPL_CFG_BCC590_WORKAROUNDS 25 | 26 | #endif 27 | 28 | #endif // BOOST_MPL_AUX_CONFIG_BCC_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/bind.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 4 | 5 | // Copyright David Abrahams 2002 6 | // Copyright Aleksey Gurtovoy 2002-2004 7 | // 8 | // Distributed under the Boost Software License, Version 1.0. 9 | // (See accompanying file LICENSE_1_0.txt or copy at 10 | // http://www.boost.org/LICENSE_1_0.txt) 11 | // 12 | // See http://www.boost.org/libs/mpl for documentation. 13 | 14 | // $Id$ 15 | // $Date$ 16 | // $Revision$ 17 | 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_BIND_TEMPLATE) \ 22 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 23 | && ( BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 24 | || BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) \ 25 | ) 26 | 27 | # define BOOST_MPL_CFG_NO_BIND_TEMPLATE 28 | 29 | #endif 30 | 31 | //#define BOOST_MPL_CFG_NO_UNNAMED_PLACEHOLDER_SUPPORT 32 | 33 | #endif // BOOST_MPL_AUX_CONFIG_BIND_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/ctps.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if !defined(BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC) \ 21 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 22 | && BOOST_WORKAROUND(BOOST_BORLANDC, < 0x582) 23 | 24 | # define BOOST_MPL_CFG_NO_NONTYPE_TEMPLATE_PARTIAL_SPEC 25 | 26 | #endif 27 | 28 | // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is defined in 29 | 30 | #endif // BOOST_MPL_AUX_CONFIG_CTPS_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && BOOST_WORKAROUND(__DMC__, BOOST_TESTED_AT(0x840)) 22 | 23 | # define BOOST_MPL_CFG_DMC_AMBIGUOUS_CTPS 24 | 25 | #endif 26 | 27 | #endif // BOOST_MPL_AUX_CONFIG_DMC_AMBIGUOUS_CTPS_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/forwarding.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_NO_NESTED_FORWARDING) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x610)) 22 | 23 | # define BOOST_MPL_CFG_NO_NESTED_FORWARDING 24 | 25 | #endif 26 | 27 | #endif // BOOST_MPL_AUX_CONFIG_FORWARDING_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/gcc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if defined(__GNUC__) && !defined(__EDG_VERSION__) 18 | # define BOOST_MPL_CFG_GCC ((__GNUC__ << 8) | __GNUC_MINOR__) 19 | #else 20 | # define BOOST_MPL_CFG_GCC 0 21 | #endif 22 | 23 | #endif // BOOST_MPL_AUX_CONFIG_GCC_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/gpu.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 4 | 5 | // Copyright Eric Niebler 2014 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_GPU_ENABLED) \ 20 | 21 | # define BOOST_MPL_CFG_GPU_ENABLED BOOST_GPU_ENABLED 22 | 23 | #endif 24 | 25 | #if defined __CUDACC__ 26 | 27 | # define BOOST_MPL_CFG_GPU 1 28 | 29 | #else 30 | 31 | # define BOOST_MPL_CFG_GPU 0 32 | 33 | #endif 34 | 35 | #endif // BOOST_MPL_AUX_CONFIG_GPU_HPP_INCLUDED 36 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/has_apply.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) \ 22 | && ( defined(BOOST_MPL_CFG_NO_HAS_XXX) \ 23 | || BOOST_WORKAROUND(__EDG_VERSION__, < 300) \ 24 | || BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \ 25 | || BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202)) \ 26 | ) 27 | 28 | # define BOOST_MPL_CFG_NO_HAS_APPLY 29 | 30 | #endif 31 | 32 | #endif // BOOST_MPL_AUX_CONFIG_HAS_APPLY_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/intel.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | // BOOST_INTEL_CXX_VERSION is defined here: 19 | #include 20 | 21 | #endif // BOOST_MPL_AUX_CONFIG_INTEL_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/lambda.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | // agurt, 15/jan/02: full-fledged implementation requires both 21 | // template template parameters _and_ partial specialization 22 | 23 | #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) \ 24 | && ( defined(BOOST_MPL_CFG_NO_TEMPLATE_TEMPLATE_PARAMETERS) \ 25 | || defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) \ 26 | ) 27 | 28 | # define BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT 29 | 30 | #endif 31 | 32 | #endif // BOOST_MPL_AUX_CONFIG_LAMBDA_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/msvc.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | // BOOST_MSVC is defined here: 19 | #include 20 | 21 | #endif // BOOST_MPL_AUX_CONFIG_MSVC_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/msvc_typename.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 21 | # define BOOST_MSVC_TYPENAME 22 | #else 23 | # define BOOST_MSVC_TYPENAME typename 24 | #endif 25 | 26 | #endif // BOOST_MPL_AUX_CONFIG_MSVC_TYPENAME_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/overload_resolution.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION) \ 20 | && !defined(BOOST_MPL_PREPROCESSING_MODE) \ 21 | && ( BOOST_WORKAROUND(BOOST_BORLANDC, < 0x590) \ 22 | || BOOST_WORKAROUND(__MWERKS__, < 0x3001) \ 23 | ) 24 | 25 | # define BOOST_MPL_CFG_BROKEN_OVERLOAD_RESOLUTION 26 | 27 | #endif 28 | 29 | #endif // BOOST_MPL_AUX_CONFIG_OVERLOAD_RESOLUTION_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/pp_counter.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2006 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_AUX_PP_COUNTER) 18 | # include 19 | # if BOOST_WORKAROUND(BOOST_MSVC, >= 1300) 20 | # define BOOST_MPL_AUX_PP_COUNTER() __COUNTER__ 21 | # else 22 | # define BOOST_MPL_AUX_PP_COUNTER() __LINE__ 23 | # endif 24 | #endif 25 | 26 | #endif // BOOST_MPL_AUX_CONFIG_PP_COUNTER_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/static_constant.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_PREPROCESSING_MODE) 18 | // BOOST_STATIC_CONSTANT is defined here: 19 | # include 20 | #else 21 | // undef the macro for the preprocessing mode 22 | # undef BOOST_STATIC_CONSTANT 23 | #endif 24 | 25 | #endif // BOOST_MPL_AUX_CONFIG_STATIC_CONSTANT_HPP_INCLUDED 26 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/use_preprocessed.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | // #define BOOST_MPL_CFG_NO_PREPROCESSED_HEADERS 18 | 19 | #endif // BOOST_MPL_AUX_CONFIG_USE_PREPROCESSED_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/config/workaround.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #endif // BOOST_MPL_AUX_CONFIG_WORKAROUND_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/has_apply.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | namespace boost { namespace mpl { namespace aux { 21 | #if !defined(BOOST_MPL_CFG_NO_HAS_APPLY) 22 | BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_apply, apply, false) 23 | #else 24 | template< typename T, typename fallback_ = false_ > 25 | struct has_apply 26 | : fallback_ 27 | { 28 | }; 29 | #endif 30 | }}} 31 | 32 | #endif // BOOST_MPL_AUX_HAS_APPLY_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/has_tag.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | namespace boost { namespace mpl { namespace aux { 20 | BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_tag, tag, false) 21 | }}} 22 | 23 | #endif // BOOST_MPL_AUX_HAS_TAG_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/has_type.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | namespace boost { namespace mpl { namespace aux { 20 | BOOST_MPL_HAS_XXX_TRAIT_NAMED_DEF(has_type, type, true) 21 | }}} 22 | 23 | #endif // BOOST_MPL_AUX_HAS_TYPE_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/lambda_arity_param.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if !defined(BOOST_MPL_CFG_EXTENDED_TEMPLATE_PARAMETERS_MATCHING) 20 | # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) 21 | #else 22 | # define BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(param) , param 23 | #endif 24 | 25 | #endif // BOOST_MPL_AUX_LAMBDA_ARITY_PARAM_HPP_INCLUDED 26 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/msvc_never_true.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) 21 | 22 | namespace boost { namespace mpl { namespace aux { 23 | 24 | template< typename T > 25 | struct msvc_never_true 26 | { 27 | enum { value = false }; 28 | }; 29 | 30 | }}} 31 | 32 | #endif // BOOST_MSVC 33 | 34 | #endif // BOOST_MPL_AUX_MSVC_NEVER_TRUE_HPP_INCLUDED 35 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/na_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | // n.a. == not available 22 | struct na 23 | { 24 | typedef na type; 25 | enum { value = 0 }; 26 | }; 27 | 28 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 29 | BOOST_MPL_AUX_ADL_BARRIER_DECL(na) 30 | 31 | #endif // BOOST_MPL_AUX_NA_FWD_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/nttp_decl.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if defined(BOOST_MPL_CFG_NTTP_BUG) 20 | 21 | typedef bool _mpl_nttp_bool; 22 | typedef int _mpl_nttp_int; 23 | typedef unsigned _mpl_nttp_unsigned; 24 | typedef long _mpl_nttp_long; 25 | 26 | # include 27 | # define BOOST_MPL_AUX_NTTP_DECL(T, x) BOOST_PP_CAT(_mpl_nttp_,T) x /**/ 28 | 29 | #else 30 | 31 | # define BOOST_MPL_AUX_NTTP_DECL(T, x) T x /**/ 32 | 33 | #endif 34 | 35 | #endif // BOOST_MPL_AUX_NTTP_DECL_HPP_INCLUDED 36 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc551/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2008 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // *Preprocessed* version of the main "template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/msvc60/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/bind_fwd.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { 13 | 14 | template< 15 | typename F 16 | > 17 | struct bind0; 18 | 19 | template< 20 | typename F, typename T1 21 | > 22 | struct bind1; 23 | 24 | template< 25 | typename F, typename T1, typename T2 26 | > 27 | struct bind2; 28 | 29 | template< 30 | typename F, typename T1, typename T2, typename T3 31 | > 32 | struct bind3; 33 | 34 | template< 35 | typename F, typename T1, typename T2, typename T3, typename T4 36 | > 37 | struct bind4; 38 | 39 | template< 40 | typename F, typename T1, typename T2, typename T3, typename T4 41 | , typename T5 42 | > 43 | struct bind5; 44 | 45 | }} 46 | 47 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2000-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/quote.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | namespace boost { namespace mpl { namespace aux { 13 | 14 | template< bool > 15 | struct template_arity_impl 16 | { 17 | template< typename F > struct result_ 18 | : mpl::int_< -1 > 19 | { 20 | }; 21 | }; 22 | 23 | template<> 24 | struct template_arity_impl 25 | { 26 | template< typename F > struct result_ 27 | : F::arity 28 | { 29 | }; 30 | }; 31 | 32 | template< typename F > 33 | struct template_arity 34 | : template_arity_impl< ::boost::mpl::aux::has_rebind::value > 35 | ::template result_ 36 | { 37 | }; 38 | 39 | }}} 40 | 41 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessed/plain/template_arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright Aleksey Gurtovoy 2001-2004 3 | // 4 | // Distributed under the Boost Software License, Version 1.0. 5 | // (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | 9 | // Preprocessed version of "boost/mpl/aux_/template_arity.hpp" header 10 | // -- DO NOT modify by hand! 11 | 12 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/preprocessor/range.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2002-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #define BOOST_MPL_PP_RANGE_ITEM(z,n,_) (n) 22 | 23 | #define BOOST_MPL_PP_RANGE(first, length) \ 24 | BOOST_PP_SEQ_SUBSEQ( \ 25 | BOOST_PP_REPEAT(BOOST_PP_ADD(first,length), BOOST_MPL_PP_RANGE_ITEM, _), \ 26 | first, length \ 27 | ) \ 28 | /**/ 29 | 30 | #endif // BOOST_MPL_AUX_PREPROCESSOR_RANGE_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/static_cast.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x561)) \ 20 | || BOOST_WORKAROUND(__GNUC__, < 3) \ 21 | || BOOST_WORKAROUND(__MWERKS__, <= 0x3001) 22 | # define BOOST_MPL_AUX_STATIC_CAST(T, expr) (T)(expr) 23 | #else 24 | # define BOOST_MPL_AUX_STATIC_CAST(T, expr) static_cast(expr) 25 | #endif 26 | 27 | #endif // BOOST_MPL_AUX_STATIC_CAST_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/aux_/template_arity_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | namespace boost { namespace mpl { namespace aux { 18 | 19 | template< typename F > struct template_arity; 20 | 21 | }}} 22 | 23 | #endif // BOOST_MPL_AUX_TEMPLATE_ARITY_FWD_HPP_INCLUDED 24 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/bool_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_BOOL_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_BOOL_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | template< bool C_ > struct bool_; 22 | 23 | // shorcuts 24 | typedef bool_ true_; 25 | typedef bool_ false_; 26 | 27 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 28 | 29 | BOOST_MPL_AUX_ADL_BARRIER_DECL(bool_) 30 | BOOST_MPL_AUX_ADL_BARRIER_DECL(true_) 31 | BOOST_MPL_AUX_ADL_BARRIER_DECL(false_) 32 | 33 | #endif // BOOST_MPL_BOOL_FWD_HPP_INCLUDED 34 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/equal_to.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_EQUAL_TO_HPP_INCLUDED 3 | #define BOOST_MPL_EQUAL_TO_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #define AUX778076_OP_NAME equal_to 18 | #define AUX778076_OP_TOKEN == 19 | #include 20 | 21 | #endif // BOOST_MPL_EQUAL_TO_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/int.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INT_HPP_INCLUDED 3 | #define BOOST_MPL_INT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #define AUX_WRAPPER_VALUE_TYPE int 20 | #include 21 | 22 | #endif // BOOST_MPL_INT_HPP_INCLUDED 23 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/int_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INT_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_INT_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 21 | 22 | template< BOOST_MPL_AUX_NTTP_DECL(int, N) > struct int_; 23 | 24 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 25 | BOOST_MPL_AUX_ADL_BARRIER_DECL(int_) 26 | 27 | #endif // BOOST_MPL_INT_FWD_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/integral_c_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2006 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | 20 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 21 | 22 | #if BOOST_WORKAROUND(__HP_aCC, <= 53800) 23 | // the type of non-type template arguments may not depend on template arguments 24 | template< typename T, long N > struct integral_c; 25 | #else 26 | template< typename T, T N > struct integral_c; 27 | #endif 28 | 29 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 30 | BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c) 31 | 32 | #endif // BOOST_MPL_INTEGRAL_C_FWD_HPP_INCLUDED 33 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/integral_c_tag.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 3 | #define BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | 18 | #include 19 | #include 20 | 21 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 22 | struct integral_c_tag { BOOST_STATIC_CONSTANT(int, value = 0); }; 23 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 24 | BOOST_MPL_AUX_ADL_BARRIER_DECL(integral_c_tag) 25 | 26 | #endif // BOOST_MPL_INTEGRAL_C_TAG_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/lambda.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LAMBDA_HPP_INCLUDED 3 | #define BOOST_MPL_LAMBDA_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | #include 19 | #include 20 | 21 | #if !defined(BOOST_MPL_CFG_NO_FULL_LAMBDA_SUPPORT) 22 | # include 23 | #else 24 | # include 25 | # include 26 | # define BOOST_MPL_CFG_NO_IMPLICIT_METAFUNCTIONS 27 | #endif 28 | 29 | #endif // BOOST_MPL_LAMBDA_HPP_INCLUDED 30 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/less.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LESS_HPP_INCLUDED 3 | #define BOOST_MPL_LESS_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #define AUX778076_OP_NAME less 18 | #define AUX778076_OP_TOKEN < 19 | #include 20 | 21 | #endif // BOOST_MPL_LESS_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/limits/arity.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 3 | #define BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #if !defined(BOOST_MPL_LIMIT_METAFUNCTION_ARITY) 18 | # define BOOST_MPL_LIMIT_METAFUNCTION_ARITY 5 19 | #endif 20 | 21 | #endif // BOOST_MPL_LIMITS_ARITY_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/next.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_NEXT_HPP_INCLUDED 3 | #define BOOST_MPL_NEXT_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | #endif // BOOST_MPL_NEXT_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/times.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_TIMES_HPP_INCLUDED 3 | #define BOOST_MPL_TIMES_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2000-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #define AUX778076_OP_NAME times 18 | #define AUX778076_OP_TOKEN * 19 | #include 20 | 21 | #endif // BOOST_MPL_TIMES_HPP_INCLUDED 22 | -------------------------------------------------------------------------------- /src/vendor/boost/mpl/void_fwd.hpp: -------------------------------------------------------------------------------- 1 | 2 | #ifndef BOOST_MPL_VOID_FWD_HPP_INCLUDED 3 | #define BOOST_MPL_VOID_FWD_HPP_INCLUDED 4 | 5 | // Copyright Aleksey Gurtovoy 2001-2004 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // (See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/mpl for documentation. 12 | 13 | // $Id$ 14 | // $Date$ 15 | // $Revision$ 16 | 17 | #include 18 | 19 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_OPEN 20 | 21 | struct void_; 22 | 23 | BOOST_MPL_AUX_ADL_BARRIER_NAMESPACE_CLOSE 24 | BOOST_MPL_AUX_ADL_BARRIER_DECL(void_) 25 | 26 | #endif // BOOST_MPL_VOID_FWD_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/noncopyable.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_NONCOPYABLE_HPP 10 | #define BOOST_NONCOPYABLE_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/noncopyable.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/numeric/conversion/bounds.hpp: -------------------------------------------------------------------------------- 1 | // (c) Copyright Fernando Luis Cacciola Carballal 2000-2004 2 | // Use, modification, and distribution is subject to the Boost Software 3 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See library home page at http://www.boost.org/libs/numeric/conversion 7 | // 8 | // Contact the author at: fernando_cacciola@hotmail.com 9 | // 10 | #ifndef BOOST_NUMERIC_CONVERSION_BOUNDS_12NOV2002_HPP 11 | #define BOOST_NUMERIC_CONVERSION_BOUNDS_12NOV2002_HPP 12 | 13 | #include "boost/numeric/conversion/detail/bounds.hpp" 14 | 15 | namespace boost { namespace numeric 16 | { 17 | 18 | template 19 | struct bounds : boundsdetail::get_impl::type 20 | {} ; 21 | 22 | } } // namespace boost::numeric 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /src/vendor/boost/numeric/conversion/int_float_mixture_enum.hpp: -------------------------------------------------------------------------------- 1 | // (c) Copyright Fernando Luis Cacciola Carballal 2000-2004 2 | // Use, modification, and distribution is subject to the Boost Software 3 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See library home page at http://www.boost.org/libs/numeric/conversion 7 | // 8 | // Contact the author at: fernando_cacciola@hotmail.com 9 | // 10 | #ifndef BOOST_NUMERIC_CONVERSION_INT_FLOAT_MIXTURE_ENUM_FLC_12NOV2002_HPP 11 | #define BOOST_NUMERIC_CONVERSION_INT_FLOAT_MIXTURE_ENUM_FLC_12NOV2002_HPP 12 | 13 | namespace boost { namespace numeric 14 | { 15 | enum int_float_mixture_enum 16 | { 17 | integral_to_integral 18 | ,integral_to_float 19 | ,float_to_integral 20 | ,float_to_float 21 | } ; 22 | 23 | } } // namespace boost::numeric 24 | 25 | #endif 26 | // 27 | /////////////////////////////////////////////////////////////////////////////////////////////// 28 | 29 | 30 | -------------------------------------------------------------------------------- /src/vendor/boost/numeric/conversion/sign_mixture_enum.hpp: -------------------------------------------------------------------------------- 1 | // (c) Copyright Fernando Luis Cacciola Carballal 2000-2004 2 | // Use, modification, and distribution is subject to the Boost Software 3 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See library home page at http://www.boost.org/libs/numeric/conversion 7 | // 8 | // Contact the author at: fernando_cacciola@hotmail.com 9 | // 10 | #ifndef BOOST_NUMERIC_CONVERSION_SIGN_MIXTURE_ENUM_FLC_12NOV2002_HPP 11 | #define BOOST_NUMERIC_CONVERSION_SIGN_MIXTURE_ENUM_FLC_12NOV2002_HPP 12 | 13 | namespace boost { namespace numeric 14 | { 15 | enum sign_mixture_enum 16 | { 17 | unsigned_to_unsigned 18 | ,signed_to_signed 19 | ,signed_to_unsigned 20 | ,unsigned_to_signed 21 | } ; 22 | 23 | } } // namespace boost::numeric 24 | 25 | #endif 26 | // 27 | /////////////////////////////////////////////////////////////////////////////////////////////// 28 | 29 | 30 | -------------------------------------------------------------------------------- /src/vendor/boost/numeric/conversion/udt_builtin_mixture_enum.hpp: -------------------------------------------------------------------------------- 1 | // (c) Copyright Fernando Luis Cacciola Carballal 2000-2004 2 | // Use, modification, and distribution is subject to the Boost Software 3 | // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | // See library home page at http://www.boost.org/libs/numeric/conversion 7 | // 8 | // Contact the author at: fernando_cacciola@hotmail.com 9 | // 10 | #ifndef BOOST_NUMERIC_CONVERSION_UDT_BUILTIN_MIXTURE_ENUM_FLC_12NOV2002_HPP 11 | #define BOOST_NUMERIC_CONVERSION_UDT_BUILTIN_MIXTURE_ENUM_FLC_12NOV2002_HPP 12 | 13 | namespace boost { namespace numeric 14 | { 15 | enum udt_builtin_mixture_enum 16 | { 17 | builtin_to_builtin 18 | ,builtin_to_udt 19 | ,udt_to_builtin 20 | ,udt_to_udt 21 | } ; 22 | 23 | } } // namespace boost::numeric 24 | 25 | #endif 26 | 27 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/comma_if.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_COMMA_IF_HPP 13 | # define BOOST_PREPROCESSOR_COMMA_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/control/if.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_CONTROL_IF_HPP 15 | # define BOOST_PREPROCESSOR_CONTROL_IF_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_IF */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_IF(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) 25 | # else 26 | # define BOOST_PP_IF(cond, t, f) BOOST_PP_IF_I(cond, t, f) 27 | # define BOOST_PP_IF_I(cond, t, f) BOOST_PP_IIF(BOOST_PP_BOOL(cond), t, f) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/dec.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_DEC_HPP 13 | # define BOOST_PREPROCESSOR_DEC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/empty.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_EMPTY_HPP 13 | # define BOOST_PREPROCESSOR_EMPTY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/enum_shifted_params.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 13 | # define BOOST_PREPROCESSOR_ENUM_SHIFTED_PARAMS_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/expr_if.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_EXPR_IF_HPP 13 | # define BOOST_PREPROCESSOR_EXPR_IF_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/facilities/empty.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 15 | # define BOOST_PREPROCESSOR_FACILITIES_EMPTY_HPP 16 | # 17 | # include 18 | # 19 | # /* BOOST_PP_EMPTY */ 20 | # 21 | # define BOOST_PP_EMPTY() 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/facilities/expand.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP 15 | # define BOOST_PREPROCESSOR_FACILITIES_EXPAND_HPP 16 | # 17 | # include 18 | # 19 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MWCC() && ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_DMC() 20 | # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_I(x) 21 | # else 22 | # define BOOST_PP_EXPAND(x) BOOST_PP_EXPAND_OO((x)) 23 | # define BOOST_PP_EXPAND_OO(par) BOOST_PP_EXPAND_I ## par 24 | # endif 25 | # 26 | # define BOOST_PP_EXPAND_I(x) x 27 | # 28 | # endif 29 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/facilities/identity.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # /* Revised by Edward Diener (2015) */ 12 | # 13 | # /* See http://www.boost.org for most recent version. */ 14 | # 15 | # ifndef BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 16 | # define BOOST_PREPROCESSOR_FACILITIES_IDENTITY_HPP 17 | # 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_IDENTITY */ 22 | # 23 | # define BOOST_PP_IDENTITY(item) item BOOST_PP_EMPTY 24 | # 25 | # define BOOST_PP_IDENTITY_N(item,n) item BOOST_PP_TUPLE_EAT_N(n) 26 | # 27 | # endif 28 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/facilities/is_1.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2003. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP 13 | # define BOOST_PREPROCESSOR_FACILITIES_IS_1_HPP 14 | # 15 | # include 16 | # include 17 | # 18 | # /* BOOST_PP_IS_1 */ 19 | # 20 | # define BOOST_PP_IS_1(x) BOOST_PP_IS_EMPTY(BOOST_PP_CAT(BOOST_PP_IS_1_HELPER_, x)) 21 | # define BOOST_PP_IS_1_HELPER_1 22 | # 23 | # endif 24 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/facilities/is_empty.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2003. 4 | # * (C) Copyright Edward Diener 2014. 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # * * 9 | # ************************************************************************** */ 10 | # 11 | # /* See http://www.boost.org for most recent version. */ 12 | # 13 | # ifndef BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP 14 | # define BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP 15 | # 16 | # include 17 | # include 18 | # 19 | # endif /* BOOST_PREPROCESSOR_FACILITIES_IS_EMPTY_HPP */ 20 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/identity.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_IDENTITY_HPP 13 | # define BOOST_PREPROCESSOR_IDENTITY_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/inc.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_INC_HPP 13 | # define BOOST_PREPROCESSOR_INC_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/iterate.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ITERATE_HPP 13 | # define BOOST_PREPROCESSOR_ITERATE_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/iteration/detail/self.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # if !defined(BOOST_PP_INDIRECT_SELF) 13 | # error BOOST_PP_ERROR: no indirect file to include 14 | # endif 15 | # 16 | # define BOOST_PP_IS_SELFISH 1 17 | # 18 | # include BOOST_PP_INDIRECT_SELF 19 | # 20 | # undef BOOST_PP_IS_SELFISH 21 | # undef BOOST_PP_INDIRECT_SELF 22 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/iteration/self.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_ITERATION_SELF_HPP 13 | # define BOOST_PREPROCESSOR_ITERATION_SELF_HPP 14 | # 15 | # /* BOOST_PP_INCLUDE_SELF */ 16 | # 17 | # define BOOST_PP_INCLUDE_SELF() 18 | # 19 | # endif 20 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/logical/and.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_LOGICAL_AND_HPP 15 | # define BOOST_PREPROCESSOR_LOGICAL_AND_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_AND */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_AND(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) 25 | # else 26 | # define BOOST_PP_AND(p, q) BOOST_PP_AND_I(p, q) 27 | # define BOOST_PP_AND_I(p, q) BOOST_PP_BITAND(BOOST_PP_BOOL(p), BOOST_PP_BOOL(q)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/logical/not.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_LOGICAL_NOT_HPP 15 | # define BOOST_PREPROCESSOR_LOGICAL_NOT_HPP 16 | # 17 | # include 18 | # include 19 | # include 20 | # 21 | # /* BOOST_PP_NOT */ 22 | # 23 | # if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_EDG() 24 | # define BOOST_PP_NOT(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x)) 25 | # else 26 | # define BOOST_PP_NOT(x) BOOST_PP_NOT_I(x) 27 | # define BOOST_PP_NOT_I(x) BOOST_PP_COMPL(BOOST_PP_BOOL(x)) 28 | # endif 29 | # 30 | # endif 31 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/punctuation/comma.hpp: -------------------------------------------------------------------------------- 1 | # /* Copyright (C) 2001 2 | # * Housemarque Oy 3 | # * http://www.housemarque.com 4 | # * 5 | # * Distributed under the Boost Software License, Version 1.0. (See 6 | # * accompanying file LICENSE_1_0.txt or copy at 7 | # * http://www.boost.org/LICENSE_1_0.txt) 8 | # */ 9 | # 10 | # /* Revised by Paul Mensonides (2002) */ 11 | # 12 | # /* See http://www.boost.org for most recent version. */ 13 | # 14 | # ifndef BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 15 | # define BOOST_PREPROCESSOR_PUNCTUATION_COMMA_HPP 16 | # 17 | # /* BOOST_PP_COMMA */ 18 | # 19 | # define BOOST_PP_COMMA() , 20 | # 21 | # endif 22 | -------------------------------------------------------------------------------- /src/vendor/boost/preprocessor/repeat.hpp: -------------------------------------------------------------------------------- 1 | # /* ************************************************************************** 2 | # * * 3 | # * (C) Copyright Paul Mensonides 2002. 4 | # * Distributed under the Boost Software License, Version 1.0. (See 5 | # * accompanying file LICENSE_1_0.txt or copy at 6 | # * http://www.boost.org/LICENSE_1_0.txt) 7 | # * * 8 | # ************************************************************************** */ 9 | # 10 | # /* See http://www.boost.org for most recent version. */ 11 | # 12 | # ifndef BOOST_PREPROCESSOR_REPEAT_HPP 13 | # define BOOST_PREPROCESSOR_REPEAT_HPP 14 | # 15 | # include 16 | # 17 | # endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/ptr_container/detail/throw_exception.hpp: -------------------------------------------------------------------------------- 1 | // 2 | // Boost.Pointer Container 3 | // 4 | // Copyright Thorsten Ottosen 2006. Use, modification and 5 | // distribution is subject to the Boost Software License, Version 6 | // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt) 8 | // 9 | // For more information, see http://www.boost.org/libs/ptr_container/ 10 | // 11 | 12 | #ifndef BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION 13 | #define BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION 14 | 15 | #include 16 | #include 17 | 18 | #ifdef BOOST_NO_EXCEPTIONS 19 | #define BOOST_PTR_CONTAINER_NO_EXCEPTIONS 20 | #endif 21 | 22 | #ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS 23 | 24 | #define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) BOOST_ASSERT( !(If) && Msg ) 25 | 26 | #else 27 | 28 | #define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) if( (If) ) throw Ex ( Msg ) 29 | 30 | #endif // BOOST_PTR_CONTAINER_NO_EXCEPTIONS 31 | 32 | 33 | #endif 34 | -------------------------------------------------------------------------------- /src/vendor/boost/range/detail/misc_concept.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Range library concept checks 2 | // 3 | // Copyright Neil Groves 2009. Use, modification and distribution 4 | // are subject to the Boost Software License, Version 1.0. (See 5 | // accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | #ifndef BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED 9 | #define BOOST_RANGE_DETAIL_MISC_CONCEPT_HPP_INCLUDED 10 | 11 | #include 12 | 13 | namespace boost 14 | { 15 | namespace range_detail 16 | { 17 | template 18 | class SameTypeConcept 19 | { 20 | public: 21 | BOOST_CONCEPT_USAGE(SameTypeConcept) 22 | { 23 | same_type(a,b); 24 | } 25 | private: 26 | template void same_type(T,T) {} 27 | T1 a; 28 | T2 b; 29 | }; 30 | } 31 | } 32 | 33 | #endif // include guard 34 | -------------------------------------------------------------------------------- /src/vendor/boost/range/empty.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Range library 2 | // 3 | // Copyright Thorsten Ottosen 2003-2004. Use, modification and 4 | // distribution is subject to the Boost Software License, Version 5 | // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | // For more information, see http://www.boost.org/libs/range/ 9 | // 10 | 11 | #ifndef BOOST_RANGE_EMPTY_HPP 12 | #define BOOST_RANGE_EMPTY_HPP 13 | 14 | #if defined(_MSC_VER) 15 | # pragma once 16 | #endif 17 | 18 | #include 19 | #include 20 | #include 21 | 22 | namespace boost 23 | { 24 | 25 | template< class T > 26 | inline bool empty( const T& r ) 27 | { 28 | return boost::begin( r ) == boost::end( r ); 29 | } 30 | 31 | } // namespace 'boost' 32 | 33 | 34 | #endif 35 | -------------------------------------------------------------------------------- /src/vendor/boost/range/functions.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Range library 2 | // 3 | // Copyright Thorsten Ottosen 2003-2006. Use, modification and 4 | // distribution is subject to the Boost Software License, Version 5 | // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | // For more information, see http://www.boost.org/libs/range/ 9 | // 10 | 11 | #ifndef BOOST_RANGE_FUNCTIONS_HPP 12 | #define BOOST_RANGE_FUNCTIONS_HPP 13 | 14 | #if defined(_MSC_VER) 15 | # pragma once 16 | #endif 17 | 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | 26 | #endif 27 | 28 | -------------------------------------------------------------------------------- /src/vendor/boost/range/value_type.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Range library 2 | // 3 | // Copyright Thorsten Ottosen 2003-2004. Use, modification and 4 | // distribution is subject to the Boost Software License, Version 5 | // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | // 8 | // For more information, see http://www.boost.org/libs/range/ 9 | // 10 | 11 | #ifndef BOOST_RANGE_VALUE_TYPE_HPP 12 | #define BOOST_RANGE_VALUE_TYPE_HPP 13 | 14 | #if defined(_MSC_VER) 15 | # pragma once 16 | #endif 17 | 18 | #include 19 | #include 20 | 21 | #include 22 | 23 | namespace boost 24 | { 25 | template< class T > 26 | struct range_value : iterator_value< typename range_iterator::type > 27 | { }; 28 | } 29 | 30 | #endif 31 | -------------------------------------------------------------------------------- /src/vendor/boost/ref.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_REF_HPP 10 | #define BOOST_REF_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/ref.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/scoped_array.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED 2 | #define BOOST_SCOPED_ARRAY_HPP_INCLUDED 3 | 4 | // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. 5 | // Copyright (c) 2001, 2002 Peter Dimov 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/smart_ptr/ for documentation. 12 | 13 | #include 14 | 15 | #endif // #ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED 16 | -------------------------------------------------------------------------------- /src/vendor/boost/scoped_ptr.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED 2 | #define BOOST_SCOPED_PTR_HPP_INCLUDED 3 | 4 | // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. 5 | // Copyright (c) 2001, 2002 Peter Dimov 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. (See 8 | // accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt) 10 | // 11 | // See http://www.boost.org/libs/smart_ptr/ for documentation. 12 | 13 | #include 14 | 15 | #endif // #ifndef BOOST_SCOPED_PTR_HPP_INCLUDED 16 | -------------------------------------------------------------------------------- /src/vendor/boost/shared_ptr.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_SHARED_PTR_HPP_INCLUDED 2 | #define BOOST_SHARED_PTR_HPP_INCLUDED 3 | 4 | // 5 | // shared_ptr.hpp 6 | // 7 | // (C) Copyright Greg Colvin and Beman Dawes 1998, 1999. 8 | // Copyright (c) 2001-2008 Peter Dimov 9 | // 10 | // Distributed under the Boost Software License, Version 1.0. (See 11 | // accompanying file LICENSE_1_0.txt or copy at 12 | // http://www.boost.org/LICENSE_1_0.txt) 13 | // 14 | // See http://www.boost.org/libs/smart_ptr/ for documentation. 15 | // 16 | 17 | #include 18 | 19 | #endif // #ifndef BOOST_SHARED_PTR_HPP_INCLUDED 20 | -------------------------------------------------------------------------------- /src/vendor/boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_GCC_INTRINSICS_HPP_INCLUDED 2 | #define BOOST_SMART_PTR_DETAIL_SP_HAS_GCC_INTRINSICS_HPP_INCLUDED 3 | 4 | // MS compatible compilers support #pragma once 5 | 6 | #if defined(_MSC_VER) && (_MSC_VER >= 1020) 7 | # pragma once 8 | #endif 9 | 10 | 11 | // boost/smart_ptr/detail/sp_has_gcc_intrinsics.hpp 12 | // 13 | // Copyright 2020 Peter Dimov 14 | // Distributed under the Boost Software License, Version 1.0. 15 | // https://www.boost.org/LICENSE_1_0.txt 16 | // 17 | // Defines the BOOST_SP_HAS_GCC_INTRINSICS macro if the __atomic_* 18 | // intrinsics are available. 19 | 20 | 21 | #if defined( __ATOMIC_RELAXED ) && defined( __ATOMIC_ACQUIRE ) && defined( __ATOMIC_RELEASE ) && defined( __ATOMIC_ACQ_REL ) 22 | 23 | # define BOOST_SP_HAS_GCC_INTRINSICS 24 | 25 | #endif 26 | 27 | #endif // #ifndef BOOST_SMART_PTR_DETAIL_SP_HAS_GCC_INTRINSICS_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/swap.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_SWAP_HPP 10 | #define BOOST_SWAP_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/swap.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/type.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright David Abrahams 2001. 2 | // Distributed under the Boost Software License, Version 1.0. (See 3 | // accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt) 5 | 6 | #ifndef BOOST_TYPE_DWA20010120_HPP 7 | # define BOOST_TYPE_DWA20010120_HPP 8 | 9 | namespace boost { 10 | 11 | // Just a simple "type envelope". Useful in various contexts, mostly to work 12 | // around some MSVC deficiencies. 13 | template 14 | struct type {}; 15 | 16 | } 17 | 18 | #endif // BOOST_TYPE_DWA20010120_HPP 19 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/add_lvalue_reference.hpp: -------------------------------------------------------------------------------- 1 | // Copyright 2010 John Maddock 2 | 3 | // Distributed under the Boost Software License, Version 1.0. 4 | // See http://www.boost.org/LICENSE_1_0.txt 5 | 6 | #ifndef BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 7 | #define BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 8 | 9 | #include 10 | 11 | namespace boost{ 12 | 13 | template struct add_lvalue_reference 14 | { 15 | typedef typename boost::add_reference::type type; 16 | }; 17 | 18 | #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 19 | template struct add_lvalue_reference 20 | { 21 | typedef T& type; 22 | }; 23 | #endif 24 | 25 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 26 | 27 | template using add_lvalue_reference_t = typename add_lvalue_reference::type; 28 | 29 | #endif 30 | 31 | } 32 | 33 | #endif // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP 34 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/conditional.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright John Maddock 2010. 2 | // Use, modification and distribution are subject to the Boost Software License, 3 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt). 5 | // 6 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 7 | 8 | 9 | #ifndef BOOST_TT_CONDITIONAL_HPP_INCLUDED 10 | #define BOOST_TT_CONDITIONAL_HPP_INCLUDED 11 | 12 | #include 13 | 14 | namespace boost { 15 | 16 | template struct conditional { typedef T type; }; 17 | template struct conditional { typedef U type; }; 18 | 19 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 20 | 21 | template using conditional_t = typename conditional::type; 22 | 23 | #endif 24 | 25 | } // namespace boost 26 | 27 | 28 | #endif // BOOST_TT_CONDITIONAL_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/conversion_traits.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright 2000 John Maddock (john@johnmaddock.co.uk) 3 | // Copyright 2000 Jeremy Siek (jsiek@lsc.nd.edu) 4 | // Copyright 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) 5 | // 6 | // Use, modification and distribution are subject to the Boost Software License, 7 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 8 | // http://www.boost.org/LICENSE_1_0.txt). 9 | // 10 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 11 | 12 | #ifndef BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED 13 | #define BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED 14 | 15 | #include 16 | 17 | #endif // BOOST_TT_CONVERSION_TRAITS_HPP_INCLUDED 18 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/detail/yes_no_type.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright John Maddock and Steve Cleary 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | // 9 | // macros and helpers for working with integral-constant-expressions. 10 | 11 | #ifndef BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 12 | #define BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 13 | 14 | namespace boost { 15 | namespace type_traits { 16 | 17 | typedef char yes_type; 18 | struct no_type 19 | { 20 | char padding[8]; 21 | }; 22 | 23 | } // namespace type_traits 24 | } // namespace boost 25 | 26 | #endif // BOOST_TT_DETAIL_YES_NO_TYPE_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/enable_if.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright 2003 The Trustees of Indiana University 3 | 4 | Authors: Jaakko Jarvi (jajarvi at osl.iu.edu) 5 | Jeremiah Willcock (jewillco at osl.iu.edu) 6 | Andrew Lumsdaine (lums at osl.iu.edu) 7 | 8 | Copyright 2018 Glen Joseph Fernandes 9 | (glenjofe@gmail.com) 10 | 11 | Distributed under the Boost Software License, 12 | Version 1.0. (See accompanying file LICENSE_1_0.txt 13 | or copy at http://www.boost.org/LICENSE_1_0.txt) 14 | */ 15 | #ifndef BOOST_TT_ENABLE_IF_HPP_INCLUDED 16 | #define BOOST_TT_ENABLE_IF_HPP_INCLUDED 17 | 18 | #include 19 | 20 | namespace boost { 21 | 22 | template 23 | struct enable_if_ { 24 | typedef T type; 25 | }; 26 | 27 | template 28 | struct enable_if_ { }; 29 | 30 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 31 | template 32 | using enable_if_t = typename enable_if_::type; 33 | #endif 34 | 35 | } /* boost */ 36 | 37 | #endif 38 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_arithmetic.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 10 | #define BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 11 | 12 | #include 13 | #include 14 | 15 | namespace boost { 16 | 17 | template 18 | struct is_arithmetic : public integral_constant::value || is_floating_point::value> {}; 19 | 20 | } // namespace boost 21 | 22 | #endif // BOOST_TT_IS_ARITHMETIC_HPP_INCLUDED 23 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_final.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright (c) 2014 Agustin Berge 3 | // 4 | // Use, modification and distribution are subject to the Boost Software License, 5 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt). 7 | // 8 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 9 | 10 | 11 | #ifndef BOOST_TT_IS_FINAL_HPP_INCLUDED 12 | #define BOOST_TT_IS_FINAL_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | #ifdef BOOST_IS_FINAL 17 | #include 18 | #endif 19 | 20 | namespace boost { 21 | 22 | #ifdef BOOST_IS_FINAL 23 | template struct is_final : public integral_constant {}; 24 | #else 25 | template struct is_final : public integral_constant {}; 26 | #endif 27 | 28 | } // namespace boost 29 | 30 | #endif // BOOST_TT_IS_FINAL_HPP_INCLUDED 31 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_float.hpp: -------------------------------------------------------------------------------- 1 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 2 | // Use, modification and distribution are subject to the Boost Software License, 3 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 4 | // http://www.boost.org/LICENSE_1_0.txt). 5 | // 6 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 7 | 8 | #ifndef BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED 9 | #define BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED 10 | 11 | // should be the last #include 12 | #include 13 | 14 | namespace boost { 15 | 16 | //* is a type T a floating-point type described in the standard (3.9.1p8) 17 | template struct is_float : public is_floating_point {}; 18 | } // namespace boost 19 | 20 | #endif // BOOST_TYPE_TRAITS_IS_FLOAT_HPP_INCLUDED 21 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_function.hpp: -------------------------------------------------------------------------------- 1 | 2 | // Copyright 2000 John Maddock (john@johnmaddock.co.uk) 3 | // Copyright 2002 Aleksey Gurtovoy (agurtovoy@meta-comm.com) 4 | // 5 | // Use, modification and distribution are subject to the Boost Software License, 6 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 7 | // http://www.boost.org/LICENSE_1_0.txt). 8 | // 9 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 10 | 11 | #ifndef BOOST_TT_IS_FUNCTION_HPP_INCLUDED 12 | #define BOOST_TT_IS_FUNCTION_HPP_INCLUDED 13 | 14 | #include 15 | #include 16 | 17 | #ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION 18 | 19 | #include 20 | 21 | #else 22 | 23 | #include 24 | 25 | #endif 26 | 27 | #endif // BOOST_TT_IS_FUNCTION_HPP_INCLUDED 28 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_member_function_pointer.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard 3 | // Hinnant & John Maddock 2000. 4 | // Use, modification and distribution are subject to the Boost Software License, 5 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt). 7 | // 8 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 9 | 10 | 11 | #ifndef BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED 12 | #define BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED 13 | 14 | #include 15 | 16 | #ifdef BOOST_TT_HAS_ACCURATE_IS_FUNCTION 17 | 18 | #include 19 | 20 | #else 21 | 22 | #include 23 | 24 | #endif 25 | 26 | #endif // BOOST_TT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/is_void.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_IS_VOID_HPP_INCLUDED 10 | #define BOOST_TT_IS_VOID_HPP_INCLUDED 11 | 12 | #include 13 | 14 | namespace boost { 15 | 16 | template 17 | struct is_void : public false_type {}; 18 | 19 | template<> struct is_void : public true_type {}; 20 | template<> struct is_void : public true_type{}; 21 | template<> struct is_void : public true_type{}; 22 | template<> struct is_void : public true_type{}; 23 | 24 | } // namespace boost 25 | 26 | #endif // BOOST_TT_IS_VOID_HPP_INCLUDED 27 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/remove_bounds.hpp: -------------------------------------------------------------------------------- 1 | 2 | // (C) Copyright Steve Cleary, Beman Dawes, Howard Hinnant & John Maddock 2000. 3 | // Use, modification and distribution are subject to the Boost Software License, 4 | // Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at 5 | // http://www.boost.org/LICENSE_1_0.txt). 6 | // 7 | // See http://www.boost.org/libs/type_traits for most recent version including documentation. 8 | 9 | #ifndef BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED 10 | #define BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED 11 | 12 | #include 13 | 14 | namespace boost 15 | { 16 | 17 | template struct remove_bounds : public remove_extent {}; 18 | 19 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 20 | 21 | template using remove_bounds_t = typename remove_bounds::type; 22 | 23 | #endif 24 | 25 | 26 | } // namespace boost 27 | 28 | #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED 29 | -------------------------------------------------------------------------------- /src/vendor/boost/type_traits/type_identity.hpp: -------------------------------------------------------------------------------- 1 | #ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED 2 | #define BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED 3 | 4 | // 5 | // Copyright 2015 Peter Dimov 6 | // 7 | // Distributed under the Boost Software License, Version 1.0. 8 | // See accompanying file LICENSE_1_0.txt or copy at 9 | // http://www.boost.org/LICENSE_1_0.txt 10 | // 11 | 12 | #include 13 | 14 | namespace boost 15 | { 16 | 17 | template struct type_identity 18 | { 19 | typedef T type; 20 | }; 21 | 22 | #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) 23 | 24 | template using type_identity_t = typename type_identity::type; 25 | 26 | #endif 27 | 28 | 29 | } // namespace boost 30 | 31 | #endif // #ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED 32 | -------------------------------------------------------------------------------- /src/vendor/boost/utility.hpp: -------------------------------------------------------------------------------- 1 | // Boost utility.hpp header file -------------------------------------------// 2 | 3 | // Copyright 1999-2003 Aleksey Gurtovoy. Use, modification, and distribution are 4 | // subject to the Boost Software License, Version 1.0. (See accompanying file 5 | // LICENSE_1_0.txt or a copy at .) 6 | 7 | // See for the library's home page. 8 | 9 | #ifndef BOOST_UTILITY_HPP 10 | #define BOOST_UTILITY_HPP 11 | 12 | // Use of this header is discouraged and it will be deprecated. 13 | // Please include one or more of the headers below instead. 14 | 15 | #include 16 | #include 17 | #include 18 | 19 | #include 20 | #include 21 | #include 22 | #include 23 | 24 | #endif // BOOST_UTILITY_HPP 25 | -------------------------------------------------------------------------------- /src/vendor/boost/utility/enable_if.hpp: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2014 Glen Fernandes 3 | * 4 | * Distributed under the Boost Software License, Version 1.0. (See 5 | * accompanying file LICENSE_1_0.txt or copy at 6 | * http://www.boost.org/LICENSE_1_0.txt) 7 | */ 8 | 9 | #ifndef BOOST_UTILITY_ENABLE_IF_HPP 10 | #define BOOST_UTILITY_ENABLE_IF_HPP 11 | 12 | // The header file at this path is deprecated; 13 | // use boost/core/enable_if.hpp instead. 14 | 15 | #include 16 | 17 | #endif 18 | -------------------------------------------------------------------------------- /src/vendor/boost/visit_each.hpp: -------------------------------------------------------------------------------- 1 | // Boost.Signals library 2 | 3 | // Copyright Douglas Gregor 2001-2003. Use, modification and 4 | // distribution is subject to the Boost Software License, Version 5 | // 1.0. (See accompanying file LICENSE_1_0.txt or copy at 6 | // http://www.boost.org/LICENSE_1_0.txt) 7 | 8 | // For more information, see http://www.boost.org/libs/signals 9 | 10 | #ifndef BOOST_VISIT_EACH_HPP 11 | #define BOOST_VISIT_EACH_HPP 12 | 13 | namespace boost { 14 | template 15 | inline void visit_each(Visitor& visitor, const T& t, long) 16 | { 17 | visitor(t); 18 | } 19 | 20 | template 21 | inline void visit_each(Visitor& visitor, const T& t) 22 | { 23 | visit_each(visitor, t, 0); 24 | } 25 | } 26 | 27 | #endif // BOOST_VISIT_EACH_HPP 28 | -------------------------------------------------------------------------------- /tests/testthat.R: -------------------------------------------------------------------------------- 1 | # This file is part of the standard setup for testthat. 2 | # It is recommended that you do not modify it. 3 | # 4 | # Where should you do additional test configuration? 5 | # Learn more about the roles of various files in: 6 | # * https://r-pkgs.org/tests.html 7 | # * https://testthat.r-lib.org/reference/test_package.html#special-files 8 | 9 | library(testthat) 10 | library(RPostgres) 11 | 12 | test_check("RPostgres") 13 | -------------------------------------------------------------------------------- /tests/testthat/data/large_object.txt: -------------------------------------------------------------------------------- 1 | postgres -------------------------------------------------------------------------------- /tests/testthat/helper-with_database_connection.R: -------------------------------------------------------------------------------- 1 | #' Execute an R expression with access to a database connection. 2 | #' 3 | #' @param expr expression. Any R expression. 4 | #' @param con PqConnection. A database connection, by default. 5 | #' \code{dbConnect(RPostgres::Postgres())}. 6 | #' @return the return value of the evaluated \code{expr}. 7 | with_database_connection <- function(expr, con = postgresDefault()) { 8 | context <- list2env(list(con = con), parent = parent.frame()) 9 | eval(substitute(expr), envir = context) 10 | } 11 | -------------------------------------------------------------------------------- /tests/testthat/helper-with_table.R: -------------------------------------------------------------------------------- 1 | #' Run an expression that creates and touches a table, then clean up. 2 | #' 3 | #' @param con PqConnection. The database connection. 4 | #' @param tbl character. The table name. 5 | #' @param expr expression. The R expression to execute. 6 | #' @return the return value of the \code{expr}. 7 | with_table <- function(con, tbl, expr) { 8 | on.exit(DBI::dbRemoveTable(con, tbl), add = TRUE) 9 | force(expr) 10 | } 11 | -------------------------------------------------------------------------------- /tests/testthat/helper-without_rownames.R: -------------------------------------------------------------------------------- 1 | without_rownames <- function(df) { 2 | row.names(df) <- NULL 3 | df 4 | } 5 | -------------------------------------------------------------------------------- /tests/testthat/test-DBItest.R: -------------------------------------------------------------------------------- 1 | if (Sys.getenv("GITHUB_ACTIONS") == "true" || (postgresHasDefault() && identical(Sys.getenv("NOT_CRAN"), "true"))) { 2 | if (rlang::is_installed("DBItest")) { 3 | DBItest::test_all() 4 | } 5 | } 6 | -------------------------------------------------------------------------------- /tests/testthat/test-Redshift.R: -------------------------------------------------------------------------------- 1 | test_that("multiplication works", { 2 | 3 | con <- tryCatch( 4 | { 5 | dbConnect(Redshift()) 6 | }, 7 | error = function(...) { 8 | testthat::skip("Test database not available") 9 | }) 10 | 11 | expect_s4_class(con, "RedshiftConnection") 12 | dbDisconnect(con) 13 | }) 14 | -------------------------------------------------------------------------------- /tests/testthat/test-bigint.R: -------------------------------------------------------------------------------- 1 | test_that("integer", { 2 | con <- postgresDefault(bigint = "integer") 3 | on.exit(dbDisconnect(con)) 4 | 5 | expect_identical(dbGetQuery(con, "SELECT COUNT(*) FROM (SELECT 1) A")[[1]], 1L) 6 | }) 7 | 8 | test_that("numeric", { 9 | con <- postgresDefault(bigint = "numeric") 10 | on.exit(dbDisconnect(con)) 11 | 12 | expect_identical(dbGetQuery(con, "SELECT COUNT(*) FROM (SELECT 1) A")[[1]], 1.0) 13 | }) 14 | 15 | test_that("character", { 16 | con <- postgresDefault(bigint = "character") 17 | on.exit(dbDisconnect(con)) 18 | 19 | expect_identical(dbGetQuery(con, "SELECT COUNT(*) FROM (SELECT 1) A")[[1]], "1") 20 | }) 21 | -------------------------------------------------------------------------------- /tests/testthat/test-data-type.R: -------------------------------------------------------------------------------- 1 | # Taken from DBI 2 | test_that("dbDataType works on a data frame", { 3 | con <- postgresDefault() 4 | on.exit(dbDisconnect(con)) 5 | 6 | df <- data.frame(x = 1:10, y = 1:10 / 2) 7 | types <- dbDataType(con, df) 8 | 9 | expect_equal(types, c(x = "INTEGER", y = "DOUBLE PRECISION")) 10 | }) 11 | -------------------------------------------------------------------------------- /tests/testthat/test-dbQuoteLiteral.R: -------------------------------------------------------------------------------- 1 | test_that("integer64 values are treated as bigints, not floats", { 2 | con <- postgresDefault() 3 | on.exit(dbDisconnect(con)) 4 | 5 | x <- structure(4.94065645841247e-324, class = "integer64") 6 | 7 | expect_equal( 8 | as.character(dbQuoteLiteral(con, x)), 9 | "1::int8" 10 | ) 11 | }) 12 | -------------------------------------------------------------------------------- /tests/testthat/test-encoding.R: -------------------------------------------------------------------------------- 1 | # Specific to RPostgres 2 | test_that("NAs encoded as NULLs", { 3 | expect_equal(encode_vector(NA), "\\N") 4 | expect_equal(encode_vector(NA_integer_), "\\N") 5 | expect_equal(encode_vector(NA_real_), "\\N") 6 | expect_equal(encode_vector(NA_character_), "\\N") 7 | }) 8 | 9 | # Specific to RPostgres 10 | test_that("special floating point values encoded correctly", { 11 | expect_equal(encode_vector(NaN), "NaN") 12 | expect_equal(encode_vector(Inf), "Infinity") 13 | expect_equal(encode_vector(-Inf), "-Infinity") 14 | }) 15 | 16 | # Specific to RPostgres 17 | test_that("special string values are escaped", { 18 | expect_equal(encode_vector("\n"), "\\n") 19 | expect_equal(encode_vector("\r"), "\\r") 20 | expect_equal(encode_vector("\b"), "\\b") 21 | }) 22 | -------------------------------------------------------------------------------- /tests/testthat/test-isTransacting.R: -------------------------------------------------------------------------------- 1 | test_that("isTransacting detects transactions correctly", { 2 | skip_on_cran() 3 | con <- postgresDefault() 4 | expect_false(postgresIsTransacting(con)) 5 | dbBegin(con) 6 | expect_true(postgresIsTransacting(con)) 7 | dbCommit(con) 8 | expect_false(postgresIsTransacting(con)) 9 | }) 10 | -------------------------------------------------------------------------------- /tests/testthat/test-types.R: -------------------------------------------------------------------------------- 1 | test_that("can manipulate classes", { 2 | expect_s3_class(set_class(1, "A"), "A") 3 | }) 4 | 5 | test_that("dbColumnInfo() knows about typnames", { 6 | con <- postgresDefault() 7 | on.exit(dbDisconnect(con)) 8 | 9 | rs <- dbSendQuery(con, "SELECT 1 as a, '[1,2,3]'::json as js") 10 | expect_equal(dbColumnInfo(rs)[[".typname"]], c("int4", "json")) 11 | 12 | res <- dbFetch(rs) 13 | expect_s3_class(res$js, "pq_json") 14 | 15 | dbClearResult(rs) 16 | }) 17 | -------------------------------------------------------------------------------- /tests/testthat/test-waitForNotify.R: -------------------------------------------------------------------------------- 1 | test_that("WaitForNotify without anything to do returns NULL", { 2 | db <- postgresDefault() 3 | n <- RPostgres::postgresWaitForNotify(db, 1) 4 | dbDisconnect(db) 5 | expect_null(n) 6 | }) 7 | 8 | test_that("WaitForNotify with a waiting message returns message", { 9 | db <- postgresDefault() 10 | dbExecute(db, 'LISTEN grapevine') 11 | dbExecute(db, "NOTIFY grapevine, 'psst'") 12 | n <- RPostgres::postgresWaitForNotify(db, 1) 13 | dbDisconnect(db) 14 | expect_identical(n$payload, 'psst') 15 | }) 16 | -------------------------------------------------------------------------------- /tools/winlibs.R: -------------------------------------------------------------------------------- 1 | if(!file.exists("../windows/libpq/include/libpq-fe.h")){ 2 | unlink("../windows", recursive = TRUE) 3 | url <- if(grepl("aarch", R.version$platform)){ 4 | "https://github.com/r-windows/bundles/releases/download/libpq-15.12/libpq-15.12-clang-aarch64.tar.xz" 5 | } else if(grepl("clang", Sys.getenv('R_COMPILED_BY'))){ 6 | "https://github.com/r-windows/bundles/releases/download/libpq-15.12/libpq-15.12-clang-x86_64.tar.xz" 7 | } else if(getRversion() >= "4.2") { 8 | "https://github.com/r-windows/bundles/releases/download/libpq-15.12/libpq-15.12-ucrt-x86_64.tar.xz" 9 | } else { 10 | "https://github.com/rwinlib/libpq/archive/v13.2.0.tar.gz" 11 | } 12 | download.file(url, basename(url), quiet = TRUE) 13 | dir.create("../windows", showWarnings = FALSE) 14 | untar(basename(url), exdir = "../windows", tar = 'internal') 15 | unlink(basename(url)) 16 | setwd("../windows") 17 | file.rename(list.files(), 'libpq') 18 | } 19 | -------------------------------------------------------------------------------- /vscode-install.r: -------------------------------------------------------------------------------- 1 | if (!require(covr)) install.packages("covr") 2 | if (!require(DBItest)) install.packages("DBItest") 3 | devtools::install(upgrade = "never") 4 | devtools::check() 5 | --------------------------------------------------------------------------------