SSOT: This document is the single source of truth for Deprecated APIs.

This document lists all deprecated APIs in the Common System library, their replacements, and migration guidance.

Language: English | 한국어

The Common System library follows semantic versioning. Deprecated APIs are marked with the [[deprecated]] attribute and will be removed in the next major version.

No currently deprecated APIs. See "Removed APIs" sections below for previously deprecated items.

File: include/kcenon/common/config/feature_flags.h

Deprecated in: v0.2.0

Planned Removal: v1.0.0

Description: Legacy macro names for feature detection and system integration have been replaced with the unified KCENON_* naming convention.

Deprecated Macros:

Reason for Deprecation:

• Standardize on KCENON_ prefix for all macros
• Eliminate naming drift across ecosystem modules
• Provide single source of truth for feature detection

Migration Guide:

#if COMMON_HAS_SOURCE_LOCATION
    #include <source_location>
#endif

#ifdef USE_THREAD_SYSTEM
    // thread system code
#endif

#include <kcenon/common/config/feature_flags.h>

#if KCENON_HAS_SOURCE_LOCATION
    #include <source_location>
#endif

#if KCENON_WITH_THREAD_SYSTEM
    // thread system code
#endif

Disabling Legacy Aliases:

To disable legacy aliases and ensure your code uses only the new KCENON_* macros:

#define KCENON_ENABLE_LEGACY_ALIASES 0
#include <kcenon/common/config/feature_flags.h>

Or via CMake:

target_compile_definitions(my_target PUBLIC KCENON_ENABLE_LEGACY_ALIASES=0)

Directory: include/kcenon/common/patterns/result/

Deprecated in: v0.2.0

Removed in: v0.2.x (Issue #266)

Description: As part of C++20 module migration preparation, the 8 individual Result headers were consolidated into 3 logical groups following Kent Beck's "Fewest Elements" principle. The deprecated headers have been removed.

Removed Headers:

Current Headers:

Reason for Removal:

• Prepare for C++20 module migration with clear module partitions
• Reduce header count from 8 to 3 (Kent Beck's "Fewest Elements")
• Simplify include dependencies
• Zero internal/external usage detected

Migration:

// Recommended: Use umbrella header
#include <kcenon/common/patterns/result.h>

// Or use consolidated headers
#include <kcenon/common/patterns/result/core.h>       // Core types
#include <kcenon/common/patterns/result/utilities.h>  // Factory functions
#include <kcenon/common/patterns/result/compat.h>     // Legacy codes

File: include/kcenon/common/interfaces/logger_interface.h

Removed in: v3.0.0 (Issue #217)

Previous Declaration:

[[deprecated("Use log(log_level, std::string_view, const source_location&) instead.")]]
virtual VoidResult log(log_level level,
                       const std::string& message,
                       const std::string& file,
                       int line,
                       const std::string& function) = 0;

Reason for Removal:

• Replaced by C++20 source_location-based API
• Type safety: source_location provides compile-time verification
• Automatic capture: Source location is captured at call site without manual parameters
• Cleaner API: Reduced parameter count improves usability

Replacement API:

virtual VoidResult log(log_level level,
                       std::string_view message,
                       const source_location& loc = source_location::current());

Migration Guide:

// Direct call with manual parameters
logger->log(log_level::info, "Operation completed", __FILE__, __LINE__, __func__);

// Custom wrapper function
void my_log(ILogger* logger, log_level level, const std::string& msg) {
    logger->log(level, msg, __FILE__, __LINE__, __func__);
}

// Direct call - source_location auto-captured
logger->log(log_level::info, "Operation completed");

// Using convenience functions (preferred)
#include <kcenon/common/logging/log_functions.h>
log_info("Operation completed");

// Using macros (preferred)
#include <kcenon/common/logging/log_macros.h>
LOG_INFO("Operation completed");

Implementation Migration:

If you have a custom ILogger implementation, update as follows:

class MyLogger : public ILogger {
public:
    VoidResult log(log_level level,
                   const std::string& message,
                   const std::string& file,
                   int line,
                   const std::string& function) override {
        // Log with file/line/function
        std::cout << file << ":" << line << " [" << function << "] " << message;
        return VoidResult::ok();
    }
};

class MyLogger : public ILogger {
public:
    // Implement the source_location-based method
    VoidResult log(log_level level,
                   std::string_view message,
                   const source_location& loc = source_location::current()) override {
        std::cout << loc.file_name() << ":" << loc.line()
                  << " [" << loc.function_name() << "] " << message;
        return VoidResult::ok();
    }
};

The following APIs were deprecated in earlier versions and have been removed in v2.0.0:

Removed in: v2.0.0 (Issue #288)

Description: The deprecated free functions for Result operations have been removed. These functions were replaced by member methods as part of the API modernization effort.

Removed Functions:

Reason for Removal:

• Member methods provide more intuitive and discoverable API
• Consistent with modern C++ standards (std::expected, std::optional)
• Improved code readability with method chaining
• Better IDE support for auto-completion

Migration Guide:

auto result = ok(42);

if (is_ok(result)) {
    auto value = get_value(result);
    // use value
}

auto mapped = map(result, [](int x) { return x * 2; });
auto chained = and_then(result, [](int x) -> Result<std::string> {
    return ok(std::to_string(x));
});
auto recovered = or_else(result, [](const error_info&) {
    return ok(0);
});

auto result = ok(42);

if (result.is_ok()) {
    auto value = result.value();
    // use value
}

auto mapped = result.map([](int x) { return x * 2; });
auto chained = result.and_then([](int x) -> Result<std::string> {
    return ok(std::to_string(x));
});
auto recovered = result.or_else([](const error_info&) {
    return ok(0);
});

See docs/guides/RESULT_MIGRATION_GUIDE.md for complete migration instructions.

Removed in: v2.0.0

Reason: The default constructor now initializes Result to an error state, making the "uninitialized" concept obsolete.

Migration:

// Before
if (result.is_uninitialized()) { ... }

// After - Check for specific error state
if (!result.is_ok()) { ... }

Status: Removed in v3.0.0

Note: These macros have been permanently removed. All code must use the standard LOG_* macros.

Migration:

// Before (no longer available)
// THREAD_LOG_INFO("Message");

// After (required)
LOG_INFO("Message");

If you need to use deprecated APIs during migration, you can suppress warnings:

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
// deprecated API usage
#pragma GCC diagnostic pop

#pragma warning(push)
#pragma warning(disable: 4996)
// deprecated API usage
#pragma warning(pop)

To catch deprecated API usage early, enable deprecation warnings in your build:

if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
    target_compile_options(${TARGET} PRIVATE -Wdeprecated-declarations)
elseif(MSVC)
    target_compile_options(${TARGET} PRIVATE /W4)
endif()

# GCC/Clang
cmake -DCMAKE_CXX_FLAGS="-Wdeprecated-declarations" ..

# Scan for deprecated usage
make 2>&1 | grep -i deprecated

All dependent systems have been notified and have completed migration to the new APIs:

For tracking the overall deprecation plan, see #213.

• CHANGELOG - Version history with deprecation notices
• API Reference - Complete API documentation
• Migration Guide - General migration guidance
• Logging Best Practices - Recommended logging patterns

If you have questions about migrating from deprecated APIs, please:

1. Check the related documentation above
2. Search existing GitHub Issues
3. Open a new issue with the question label