Alternative Interface

| Home | Libraries | People | FAQ | More

## Alternative Interface

> "It's not a question of happiness, it's a requirement. Consider the alternative” Doug Horton

As it was indicated previously `boost::optional` is the actual type returned by the `boost::convert()` main interface:

    boost::optional<TypeOut> boost::convert(TypeIn const&, Converter const&);

The signature is functionally-complete, routinely elided during compilation and is the most efficient in deploying the underlying converter. That said, the following alternative (and arguably more traditional) interface might be potentially more suitable for certain deployment scenarios (or due to personal preferences):

    TypeOut convert(TypeIn const&, Converter const&, TypeOut const& fallback_value);
    TypeOut convert(TypeIn const&, Converter const&, Functor const& fallback_functor);
    TypeOut convert(TypeIn const&, Converter const&, boost::throw_on_failure);

It still provides unambigous behavior and readability, full support for various program flows and various degrees of conversion-failure detection and processing. It can be deployed in a similar fashion as follows:

    struct fallback_func
    {
        int operator()() const { log("Failed to convert"); return 42; }
    };

    // Error-processing behavior are specified unambiguously and uniformly.
    // a) i1: Returns the provided fallback value;
    // b) i2: Calls the provided failure-processing function;
    // c) i3: Throws an exception.

    int i1 = convert<int>(str, cnv, fallback_value);
    int i2 = convert<int>(str, cnv, fallback_func());

    try
    {
        // Throwing behavior specified explicitly rather than implied.
        int i3 = convert<int>(str, cnv, boost::throw_on_failure);
    }
    catch (boost::bad_optional_access const&)
    {
      // Handle failed conversion.
    }

Still, the described interfaces are convenience wrappers around the main interface which provides the described behavior with:

    int m1 = convert<int>(str, cnv).value_or(fallback_value);
    int m2 = convert<int>(str, cnv).value_or_eval(fallback_func());
    int m3 = convert<int>(str, cnv).value();

or with the default converter defined:

    struct boost::cnv::by_default : public boost::cnv::cstream {};

    int n1 = convert<int>(str).value_or(fallback_value);
    int n2 = convert<int>(str).value_or_eval(fallback_func());
    int n3 = convert<int>(str).value();