magic_examples.cpp

/* SPDX-FileCopyrightText: Copyright (c) 2022-2026 Oğuz Toraman <oguz.toraman@tutanota.com> */
/* SPDX-License-Identifier: LGPL-3.0-only */

 
#include <iostream>
#include <magic.hpp>
#include <print>
 
using namespace Recognition;

void ExampleBasicIdentify()
{
    try {
        Magic example_magic{Magic::Flags::Mime, Magic::DEFAULT_DATABASE_FILE};
        if (!example_magic.IsValid()) {
            std::println(std::cerr, "Magic is not valid.");
            return;
        }
        auto type = example_magic.IdentifyFile(Magic::DEFAULT_DATABASE_FILE);
        std::println(
            std::cout,
            "Magic::DEFAULT_DATABASE_FILE file type: {}",
            type
        );
    } catch (const MagicException& e) {
        std::println(std::cerr, "Error: {}", e.what());
    }
}

void ExampleNoexceptIdentify()
{
    Magic example_magic;
    if (!example_magic.Open(Magic::Flags::Mime, std::nothrow)) {
        std::println(std::cerr, "Failed to open magic.");
        return;
    }
    if (example_magic.LoadDatabaseFile(std::nothrow)) {
        auto result = example_magic.IdentifyFile(
            Magic::DEFAULT_DATABASE_FILE,
            std::nothrow
        );
        std::println(
            std::cout,
            "Noexcept Magic::DEFAULT_DATABASE_FILE file type: {}",
            ToString(result)
        );
    } else {
        std::println(std::cerr, "Failed to load database.");
    }
}

void ExampleIdentifyDirectory()
{
    try {
        Magic example_magic{Magic::Flags::Mime, Magic::DEFAULT_DATABASE_FILE};
        auto  results = example_magic.IdentifyFiles(
            std::filesystem::temp_directory_path()
        );
        std::println(
            std::cout,
            "Types in the temp directory (showing up to 10):"
        );
        for (const auto& result : results | std::views::take(10)) {
            std::println(std::cout, "{}", ToString(result));
        }
    } catch (const MagicException& e) {
        std::println(std::cerr, "Error: {}", e.what());
    }
}

void ExampleCustomFlagsParameters()
{
    Magic example_magic;
    example_magic.Open({Magic::Flags::Mime, Magic::Flags::Compress});
    example_magic.LoadDatabaseFile();
    example_magic.SetParameter(Magic::Parameters::BytesMax, 2'048);
    auto value = example_magic.GetParameter(Magic::Parameters::BytesMax);
    std::println(std::cout, "BytesMax: {}", value);
    auto flags = example_magic.GetFlags();
    std::println(std::cout, "Flags: {}", ToString(flags));
}

void ExampleCheckAndCompile()
{
    if (Magic::Check()) {
        std::println(std::cout, "Database check passed.");
    } else {
        std::println(std::cerr, "Database check failed.");
    }
    if (Magic::Compile()) {
        std::println(std::cout, "Database compiled successfully.");
    } else {
        std::println(std::cerr, "Database compilation failed.");
    }
}

void ExampleProgressTracking()
{
    try {
        Magic example_magic{Magic::Flags::Mime};
        auto  tracker = Utility::MakeSharedProgressTracker();
        auto  results = example_magic.IdentifyFiles(
            std::filesystem::temp_directory_path(),
            tracker
        );
        std::println(
            std::cout,
            "Identified {} files. Completed: {}",
            results.size(),
            tracker->IsCompleted() ? "yes" : "no"
        );
        std::println(
            std::cout,
            "Final progress: {}",
            tracker->GetCompletionPercentage().ToString()
        );
    } catch (const MagicException& e) {
        std::println(std::cerr, "Error: {}", e.what());
    }
}

void ExampleContainerIdentify()
{
    try {
        Magic example_magic{Magic::Flags::MimeType};
        std::vector<std::filesystem::path> files = {
            Magic::DEFAULT_DATABASE_FILE
        };
        auto results = example_magic.IdentifyFiles(files);
        std::println(std::cout, "Container identification results:");
        for (const auto& result : results) {
            std::println(std::cout, "{}", ToString(result));
        }
    } catch (const MagicException& e) {
        std::println(std::cerr, "Error: {}", e.what());
    }
}

void ExampleLifecycleManagement()
{
    Magic example_magic;
    std::println(
        std::cout,
        "After default construction: IsOpen={}, IsDatabaseLoaded={}, IsValid={}",
        example_magic.IsOpen(),
        example_magic.IsDatabaseLoaded(),
        example_magic.IsValid()
    );
 
    example_magic.Open(Magic::Flags::None);
    std::println(
        std::cout,
        "After Open(): IsOpen={}, IsDatabaseLoaded={}, IsValid={}",
        example_magic.IsOpen(),
        example_magic.IsDatabaseLoaded(),
        example_magic.IsValid()
    );
 
    example_magic.LoadDatabaseFile();
    std::println(
        std::cout,
        "After LoadDatabaseFile(): IsOpen={}, IsDatabaseLoaded={}, IsValid={}",
        example_magic.IsOpen(),
        example_magic.IsDatabaseLoaded(),
        example_magic.IsValid()
    );
 
    example_magic.SetFlags(Magic::Flags::Mime);
    auto new_flags = example_magic.GetFlags();
    std::println(std::cout, "After SetFlags(): {}", ToString(new_flags));
 
    example_magic.Close();
    std::println(
        std::cout,
        "After Close(): IsOpen={}, IsDatabaseLoaded={}, IsValid={}",
        example_magic.IsOpen(),
        example_magic.IsDatabaseLoaded(),
        example_magic.IsValid()
    );
}

void ExampleVersionAndAllParameters()
{
    std::println(std::cout, "Libmagic version: {}", Magic::GetVersion());
 
    Magic example_magic{Magic::Flags::Mime};
    auto  all_params = example_magic.GetParameters();
    std::println(std::cout, "All parameters: {}", ToString(all_params));
 
    example_magic.SetParameters({
        {Magic::Parameters::BytesMax,  1'024'000},
        {Magic::Parameters::RegexMax,  4'096    }
    });
    auto updated_params = example_magic.GetParameters();
    std::println(
        std::cout,
        "After SetParameters(): {}",
        ToString(updated_params)
    );
}

auto main() -> int
{
    std::println(std::cout, "--- Example 1: Basic Identify ---");
    ExampleBasicIdentify();
    std::println(std::cout, "\n--- Example 2: Noexcept Identify ---");
    ExampleNoexceptIdentify();
    std::println(std::cout, "\n--- Example 3: Directory Identify ---");
    ExampleIdentifyDirectory();
    std::println(std::cout, "\n--- Example 4: Custom Flags/Parameters ---");
    ExampleCustomFlagsParameters();
    std::println(std::cout, "\n--- Example 5: Compile and Check ---");
    ExampleCheckAndCompile();
    std::println(std::cout, "\n--- Example 6: Progress Tracking ---");
    ExampleProgressTracking();
    std::println(std::cout, "\n--- Example 7: Container Identify ---");
    ExampleContainerIdentify();
    std::println(std::cout, "\n--- Example 8: Lifecycle Management ---");
    ExampleLifecycleManagement();
    std::println(std::cout, "\n--- Example 9: Version and All Parameters ---");
    ExampleVersionAndAllParameters();
    return 0;
}