boost_optional_ext

It is a pipe operator for the boost::optional

it gives you a way to write your code in an FP manner.

Sample

Consider a given interface:

namespace services
{
    class IDataProvider
    {
        public:
        using Data = std::string;
        using Connection = boost::signals2::connection;
        using FNewData = void(const Data&);
        using FNewDataHandler = std::function<FNewData>;
        virtual ~IDataProvider() = default;
        virtual void start() = 0;
        virtual void stop() = 0;
        virtual void wait() = 0;
        virtual Connection onNewData(const FNewDataHandler& handler) = 0;
    };
} // end namespace service

Conditions:

• a new data comes as the std::string
• a new data is a textual representation of floating-point type with the sign.
• the data may have an error (it isn’t a correct representation of floating-point type)
• it’s required to sum all numbers are satisfying criterion: num > 0 and num < 50
• it’s required to sum a count of errors.
• The criterion of stop: the sum >= 100.

The following code snippet implements described above.

namespace {
template<typename T>
boost::optional<const T&> toOp(const T& value)
{
    return value;
}
template<typename T>
boost::optional<T&> toOp(T& value)
{
    return value;
}
boost::optional<double> toDouble(const std::string& value)
{
    try {
        return boost::lexical_cast<double>(value);
    }
    catch (const boost::bad_lexical_cast& exc)
    {
        std::cerr << exc.what() << std::endl;
        return boost::none;
    }
}
} // end namespace
void DataConsumer::startDataHandler(service::IDataProvider& provider)
{
    double acc = 0.0;
    uint32_t errors = 0;
    provider.onNewData([&acc, &errors, &provider](const services::IDataProvider::Data& data) mutable {
        auto errorHandler = [&errors] () mutable {
            std::cout << "a wrong data recieved" << std::endl;
            errors += 1;
        };
        auto filter = [] (auto&& el)
          { 
              return std::isgreaterequal(el, 0.0) && std::islessequal(el, 50.0);
          };
        auto log = [] (auto&& el) {
            std::cout << "New Value accepted: " << el << std::endl;
        };
        /* In an old manner it would be look like this:
            try {
                auto value = boost::lexical_cast<double>(data);
                print(value);
                if (value >= 0 && value <= 50)
                {
                    std::cout << "New Value accepted: " << value << std::endl;
                    acc += value;
                }
            }
            catch (const boost::bad_lexical_cast& exc)
            {
                std::cerr << exc.what() << std::endl;
                errors += 1;
            };
        */
        // it's an example of usage boost_optional_ext
        acc += toOp(data)
                 | toDouble
                 | hof::match(print<double>, errorHandler)
                 | hof::filter_if(filter)
                 | hof::match_some(log)
                 <<= 0;
        std::cout << "----step-----ACC-[" << acc << "] " << std::endl;
        if (acc >= 100)
        {
            provider.stop();
        }
    });
    provider.start();
    provider.wait();
    std::cout << "Final Acc: [" << acc << "], Errors: " << errors << std::endl;
}

How to configure and build example and tests

1. run ./configure.sh

2. run ./build.sh

   The build artifacts are in ./Build/bin