implement .bind

Author: Fytch

ProgramOptions.hxx

@@ -21,6 +21,10 @@
 #include <cmath>
 #include <limits>
 #include <vector>
+#include <deque>
+#include <list>
+#include <stack>
+#include <queue>
 #include <memory>
 #include <unordered_map>
 #include <type_traits>
@@ -357,6 +361,50 @@ namespace po {
 	template< value_type type >
 	using vt2type = typename detail::vt2type_impl< type >::type;
 
+	namespace detail {
+		template<
+			typename T,
+			bool is_integral = std::is_integral< T >::value,
+			bool is_floating_point = std::is_floating_point< T >::value,
+			bool is_signed = std::numeric_limits< T >::is_signed
+		>
+		struct type2vt_impl {
+			// Not using false because then it would trigger without instatiation.
+			// Instead, use an expression that always evaluates to false but depends on T.
+			static_assert( !std::is_same< T, T >::value, "type2vt: unsupported type" );
+			static constexpr value_type value = void_;
+		};
+		template<>
+		struct type2vt_impl< void, false, false, false > {
+			static constexpr value_type value = void_;
+		};
+		template<>
+		struct type2vt_impl< std::string, false, false, false > {
+			static constexpr value_type value = string;
+		};
+		template< typename T >
+		struct type2vt_impl< T, true, false, true > {
+			static constexpr std::size_t T_bits = sizeof( T ) * std::numeric_limits< unsigned char >::digits;
+			static_assert( T_bits == 32 || T_bits == 64, "type2vt: only 32 or 64 bit wide signed integral types supported" );
+			static constexpr value_type value = ( T_bits == 32 ) ? i32 : i64;
+		};
+		template< typename T >
+		struct type2vt_impl< T, true, false, false > {
+			static constexpr std::size_t T_bits = sizeof( T ) * std::numeric_limits< unsigned char >::digits;
+			static_assert( T_bits == 32 || T_bits == 64, "type2vt: only 32 or 64 bit wide unsigned integral types supported" );
+			static constexpr value_type value = ( T_bits == 32 ) ? u32 : u64;
+		};
+		template< typename T >
+		struct type2vt_impl< T, false, true, true > {
+			static constexpr std::size_t T_bits = sizeof( T ) * std::numeric_limits< unsigned char >::digits;
+			static_assert( T_bits == 32 || T_bits == 64, "type2vt: only 32 or 64 bit wide floating point types supported" );
+			static constexpr value_type value = ( T_bits == 32 ) ? f32 : f64;
+		};
+	}
+	template< typename T >
+	struct type2vt : detail::type2vt_impl< typename std::remove_cv< T >::type > {
+	};
+
 	template< typename T >
 	T pow( T base, unsigned exp ) {
 		if( exp == 0 )
@@ -1604,6 +1652,47 @@ namespace po {
 			return *this;
 		}
 
+		template< typename T >
+		option& bind_container( T& target ) {
+			using value_type = typename T::value_type;
+			type( type2vt< value_type >::value );
+			multi();
+			callback( [ &target ]( value_type const& x ){ target.push_back( x ); } );
+			return *this;
+		}
+
+		template< typename T >
+		option& bind( T& target ) {
+			type( type2vt< T >::value );
+			single();
+			callback( [ &target ]( T const& x ){ target = x; } );
+			return *this;
+		}
+		template< typename T >
+		option& bind( std::vector< T >& target ) {
+			return bind_container( target );
+		}
+		template< typename T >
+		option& bind( std::deque< T >& target ) {
+			return bind_container( target );
+		}
+		template< typename T >
+		option& bind( std::list< T >& target ) {
+			return bind_container( target );
+		}
+		template< typename T >
+		option& bind( std::stack< T >& target ) {
+			return bind_container( target );
+		}
+		template< typename T >
+		option& bind( std::queue< T >& target ) {
+			return bind_container( target );
+		}
+		template< typename T >
+		option& bind( std::priority_queue< T >& target ) {
+			return bind_container( target );
+		}
+
 	private:
 		std::unique_ptr< value_vector_base > make_vector() const {
 			const bool arg1 = ( get_type() == void_ );

test/bind.cxx

@@ -0,0 +1,79 @@
+#include <catch.hpp>
+#include <ProgramOptions.hxx>
+#include "arg_provider.hxx"
+
+TEST_CASE( "bind", "[ProgramOptions]" ) {
+	po::parser parser;
+	parser.silent();
+
+	std::string a;
+	std::int32_t b{};
+	std::int64_t c{};
+	std::uint32_t d{};
+	std::uint64_t e{};
+	// float f{};
+	// double g{};
+	std::vector< std::int32_t > h;
+	std::deque< std::string > i;
+
+	auto&& a_opt = parser[ "a" ].bind( a );
+	auto&& b_opt = parser[ "b" ].bind( b );
+	auto&& c_opt = parser[ "c" ].bind( c );
+	auto&& d_opt = parser[ "d" ].bind( d );
+	auto&& e_opt = parser[ "e" ].bind( e );
+	// auto&& f_opt = parser[ "f" ].bind( f );
+	// auto&& g_opt = parser[ "g" ].bind( g );
+	auto&& h_opt = parser[ "h" ].bind( h );
+	auto&& i_opt = parser[ "i" ].bind( i );
+
+	REQUIRE( a_opt.is_single() );
+	REQUIRE( a_opt.get_type() == po::string );
+	REQUIRE( b_opt.is_single() );
+	REQUIRE( b_opt.get_type() == po::i32 );
+	REQUIRE( c_opt.is_single() );
+	REQUIRE( c_opt.get_type() == po::i64 );
+	REQUIRE( d_opt.is_single() );
+	REQUIRE( d_opt.get_type() == po::u32 );
+	REQUIRE( e_opt.is_single() );
+	REQUIRE( e_opt.get_type() == po::u64 );
+	// REQUIRE( f_opt.is_single() );
+	// REQUIRE( f_opt.get_type() == po::f32 );
+	// REQUIRE( g_opt.is_single() );
+	// REQUIRE( g_opt.get_type() == po::f64 );
+	REQUIRE( h_opt.is_multi() );
+	REQUIRE( h_opt.get_type() == po::i32 );
+	REQUIRE( i_opt.is_multi() );
+	REQUIRE( i_opt.get_type() == po::string );
+
+	SECTION( "good scenario" ) {
+		const arg_provider A {
+			"/Test",
+			"-a" "hello",
+			"-h 36",
+			"-h 42",
+			"-i" "foo",
+			"-i" "bar",
+			"-b 36",
+			"-b 42",
+		};
+
+		CHECK( parser( A.argc, A.argv ) );
+
+		REQUIRE( a_opt.count() == 1 );
+		CHECK( a == "hello" );
+
+		REQUIRE( b_opt.count() == 1 );
+		CHECK( b == 42 );
+
+		REQUIRE( h_opt.count() == 2 );
+		REQUIRE( h.size() == 2 );
+		CHECK( h[ 0 ] == 36 );
+		CHECK( h[ 1 ] == 42 );
+		CHECK( h == h_opt.to_vector< po::i32 >() );
+
+		REQUIRE( i_opt.count() == 2 );
+		REQUIRE( i.size() == 2 );
+		CHECK( i[ 0 ] == "foo" );
+		CHECK( i[ 1 ] == "bar" );
+	}
+}