kcenon::common::helpers Namespace Reference

Functions
template<typename T >
auto	return_if_error (const Result< T > &result) -> std::optional< error_info >
	Return error if Result is in error state (type-safe alternative to RETURN_IF_ERROR)
template<typename T >
auto	try_extract (Result< T > &&result) -> std::conditional_t< std::is_void_v< T >, Result< std::monostate >, Result< T > >
	Safely extract value from Result or return error.
auto	error_if (bool condition, const error_info &error) -> std::optional< error_info >
	Check condition and return error if false (type-safe alternative to RETURN_ERROR_IF)
auto	make_error (int code, const std::string &message, const std::string &module="") noexcept -> error_info
	Create error_info with code, message, and module (type-safe)
auto	make_error_with_details (int code, const std::string &message, const std::string &module, const std::string &details) noexcept -> error_info
	Create error_info with code, message, module, and details.
template<typename... Funcs>
auto	chain (Funcs &&... funcs)
	Chain multiple Result-returning operations.
template<typename Func >
auto	safe_execute (Func &&func, const std::string &module="") -> Result< std::invoke_result_t< Func > >
	Execute function and convert exceptions to Result.
template<typename T , typename ErrorHandler >
auto	unwrap_or_handle (Result< T > &&result, ErrorHandler &&error_handler) -> T
	Unwrap Result with custom error handler.
template<typename... Results>
auto	combine_results (Results &&... results) -> Result< std::tuple< typename std::decay_t< Results >::value_type... > >
	Combine multiple Results into a single Result containing a tuple.

Function Documentation

chain()

template<typename... Funcs>

auto kcenon::common::helpers::chain ( Funcs &&... funcs )

nodiscard

Chain multiple Result-returning operations.

Parameters

funcs

Variadic list of functions returning Result<T>

Returns

Result of the last successful operation, or first error

Usage: auto result = chain( []() { return operation1(); }, [](auto& r1) { return operation2(r1); }, [](auto& r2) { return operation3(r2); } );

Definition at line 138 of file result_helpers.h.

                                           {
    using FirstResult = std::invoke_result_t<std::tuple_element_t<0, std::tuple<Funcs...>>>;
 
    FirstResult result = std::get<0>(std::forward_as_tuple(funcs...))();
 
    if constexpr (sizeof...(funcs) > 1) {
        ([&]<typename Func>(Func&& func) {
            if (result.is_ok()) {
                result = func(result.value());
            }
        }(std::forward<Funcs>(funcs)), ...);
    }
 
    return result;
}

combine_results()

template<typename... Results>

auto kcenon::common::helpers::combine_results ( Results &&... results ) -> Result<std::tuple<typename std::decay_t<Results>::value_type...>>

nodiscard

Combine multiple Results into a single Result containing a tuple.

Parameters

results

Variadic list of Result objects

Returns

Result<tuple> containing all values, or first error

Usage: auto combined = combine_results( get_int(), get_string(), get_double() ); if (combined) { auto [i, s, d] = combined.value(); }

Definition at line 219 of file result_helpers.h.

{
    // Check if any result is error
    bool has_error = (... || results.is_err());
    if (has_error) {
        // Return first error found
        error_info first_error;
        ((results.is_err() && (first_error = results.error(), true)) || ...);
        return Result<std::tuple<typename std::decay_t<Results>::value_type...>>(first_error);
    }
 
    // All ok, combine values
    return Result<std::tuple<typename std::decay_t<Results>::value_type...>>(
        std::make_tuple(std::forward<Results>(results).value()...)
    );
}

error_if()

auto kcenon::common::helpers::error_if ( bool condition, const error_info & error ) -> std::optional<error_info>

inlinenodiscard

Check condition and return error if false (type-safe alternative to RETURN_ERROR_IF)

Parameters

condition	The condition to check
error	The error_info to return if condition is true

Returns

Optional error_info

Usage: if (auto err = error_if(!ptr, error_info{-1, "Null pointer", "Module"})) { return *err; }

Definition at line 83 of file result_helpers.h.

{
    if (condition) {
        return error;
    }
    return std::nullopt;
}

make_error()

auto kcenon::common::helpers::make_error ( int code, const std::string & message, const std::string & module = "" ) -> error_info

inlinenodiscardnoexcept

Create error_info with code, message, and module (type-safe)

Parameters

code	Error code
message	Error message
module	Module name

Returns

error_info object

Definition at line 99 of file result_helpers.h.

{
    return error_info{code, message, module};
}

make_error_with_details()

auto kcenon::common::helpers::make_error_with_details ( int code, const std::string & message, const std::string & module, const std::string & details ) -> error_info

inlinenodiscardnoexcept

Create error_info with code, message, module, and details.

Parameters

code	Error code
message	Error message
module	Module name
details	Additional details

Returns

error_info object

Definition at line 115 of file result_helpers.h.

{
    return error_info{code, message, module, details};
}

return_if_error()

template<typename T >

auto kcenon::common::helpers::return_if_error ( const Result< T > & result ) -> std::optional<error_info>

nodiscard

Return error if Result is in error state (type-safe alternative to RETURN_IF_ERROR)

Parameters

result

The Result to check

Returns

The error_info if result is error, otherwise continues execution

Usage: auto result = some_operation(); if (auto err = return_if_error(result)) { return *err; } // Continue with result.value()

Definition at line 43 of file result_helpers.h.

{
    if (result.is_err()) {
        return result.error();
    }
    return std::nullopt;
}

safe_execute()

template<typename Func >

auto kcenon::common::helpers::safe_execute ( Func && func, const std::string & module = "" ) -> Result<std::invoke_result_t<Func>>

nodiscard

Execute function and convert exceptions to Result.

Parameters

func	Function to execute
module	Module name for error reporting

Returns

Result containing function result or error

This is a more efficient version of try_catch from result.h

Definition at line 163 of file result_helpers.h.

{
    using ReturnType = std::invoke_result_t<Func>;
 
    try {
        if constexpr (std::is_void_v<ReturnType>) {
            func();
            return Result<std::monostate>(std::monostate{});
        } else {
            return Result<ReturnType>(func());
        }
    } catch (const std::exception& e) {
        return Result<ReturnType>(error_info{-99, e.what(), module});
    } catch (...) {
        return Result<ReturnType>(error_info{-99, "Unknown error", module});
    }
}

try_extract()

template<typename T >

auto kcenon::common::helpers::try_extract ( Result< T > && result ) -> std::conditional_t<std::is_void_v<T>, Result<std::monostate>, Result<T>>

nodiscard

Safely extract value from Result or return error.

Parameters

result

The Result to extract from

Returns

Value if ok, propagates error if err

This is a safer alternative that works at function boundaries.

Definition at line 66 of file result_helpers.h.

{
    return std::forward<Result<T>>(result);
}

unwrap_or_handle()

template<typename T , typename ErrorHandler >

auto kcenon::common::helpers::unwrap_or_handle ( Result< T > && result, ErrorHandler && error_handler ) -> T

nodiscard

Unwrap Result with custom error handler.

Parameters

result	The Result to unwrap
error_handler	Function called if result is error

Returns

Value if ok, or default-constructed T if error

Usage: int value = unwrap_or_handle(result, [](const auto& err) { log_error("Operation failed: {}", err.message); });

Definition at line 194 of file result_helpers.h.

{
    if (result.is_err()) {
        error_handler(result.error());
        return T{};
    }
    return std::move(result).value();
}