query_scu::result_formatter Class Reference

Result formatter for query results. More...

#include <result_formatter.h>

Collaboration diagram for query_scu::result_formatter:

Classes
struct	column_def
	Column definition for formatting. More...

Public Types
using	query_level = kcenon::pacs::services::query_level

Public Member Functions
	result_formatter (output_format format, query_level level)
	Construct formatter with output format.
std::string	format (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format query results.

Private Member Functions
std::string	format_table (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format results as a human-readable table.
std::string	format_json (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format results as JSON.
std::string	format_csv (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format results as CSV.
std::vector< column_def >	get_columns_for_level () const
	Get columns appropriate for the query level.

Static Private Member Functions
static std::string	get_tag_value (const kcenon::pacs::core::dicom_dataset &ds, kcenon::pacs::core::dicom_tag tag)
	Get tag value from dataset as string.
static std::string	escape_json (const std::string &s)
	Escape string for JSON output.
static std::string	escape_csv (const std::string &s)
	Escape string for CSV output.

Private Attributes
output_format	format_
query_level	level_

Detailed Description

Result formatter for query results.

Formats C-FIND query results for display in different output formats.

Examples

query_scu/main.cpp.

Definition at line 52 of file result_formatter.h.

Member Typedef Documentation

query_level

using query_scu::result_formatter::query_level = kcenon::pacs::services::query_level

Definition at line 54 of file result_formatter.h.

Constructor & Destructor Documentation

result_formatter()

query_scu::result_formatter::result_formatter ( output_format format, query_level level )

inlineexplicit

Construct formatter with output format.

Parameters

format	The output format to use
level	The query level for proper column selection

Definition at line 61 of file result_formatter.h.

        : format_(format), level_(level) {}

Member Function Documentation

escape_csv()

static std::string query_scu::result_formatter::escape_csv ( const std::string & s )

inlinestaticnodiscardprivate

Escape string for CSV output.

Definition at line 325 of file result_formatter.h.

                                                                  {
        if (s.find_first_of(",\"\n\r") == std::string::npos) {
            return s;
        }
 
        std::string result = "\"";
        for (char c : s) {
            if (c == '"') {
                result += "\"\"";
            } else {
                result += c;
            }
        }
        result += "\"";
        return result;
    }

Referenced by format_csv().

Here is the caller graph for this function:

escape_json()

static std::string query_scu::result_formatter::escape_json ( const std::string & s )

inlinestaticnodiscardprivate

Escape string for JSON output.

Definition at line 295 of file result_formatter.h.

                                                                   {
        std::string result;
        result.reserve(s.length());
        for (char c : s) {
            switch (c) {
                case '"': result += "\\\""; break;
                case '\\': result += "\\\\"; break;
                case '\b': result += "\\b"; break;
                case '\f': result += "\\f"; break;
                case '\n': result += "\\n"; break;
                case '\r': result += "\\r"; break;
                case '\t': result += "\\t"; break;
                default:
                    if (static_cast<unsigned char>(c) < 0x20) {
                        result += "\\u";
                        char buf[5];
                        std::snprintf(buf, sizeof(buf), "%04X",
                                      static_cast<unsigned char>(c));
                        result += buf;
                    } else {
                        result += c;
                    }
            }
        }
        return result;
    }

Referenced by format_json().

Here is the caller graph for this function:

format()

std::string query_scu::result_formatter::format ( const std::vector< kcenon::pacs::core::dicom_dataset > & results ) const

inlinenodiscard

Format query results.

Parameters

results

Vector of result datasets

Returns

Formatted string output

Examples

query_scu/main.cpp.

Definition at line 69 of file result_formatter.h.

                                                                     {
        switch (format_) {
            case output_format::json:
                return format_json(results);
            case output_format::csv:
                return format_csv(results);
            case output_format::table:
            default:
                return format_table(results);
        }
    }

References query_scu::csv, format_, format_csv(), format_json(), format_table(), query_scu::json, and query_scu::table.

Here is the call graph for this function:

format_csv()

std::string query_scu::result_formatter::format_csv ( const std::vector< kcenon::pacs::core::dicom_dataset > & results ) const

inlinenodiscardprivate

Format results as CSV.

Definition at line 197 of file result_formatter.h.

                                                                     {
        using namespace kcenon::pacs::core;
        std::ostringstream oss;
 
        auto columns = get_columns_for_level();
 
        // Print header row
        for (size_t i = 0; i < columns.size(); ++i) {
            oss << columns[i].header;
            if (i < columns.size() - 1) {
                oss << ",";
            }
        }
        oss << "\n";
 
        // Print data rows
        for (const auto& result : results) {
            for (size_t i = 0; i < columns.size(); ++i) {
                auto value = get_tag_value(result, columns[i].tag);
                oss << escape_csv(value);
                if (i < columns.size() - 1) {
                    oss << ",";
                }
            }
            oss << "\n";
        }
 
        return oss.str();
    }

References escape_csv(), get_columns_for_level(), and get_tag_value().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

format_json()

std::string query_scu::result_formatter::format_json ( const std::vector< kcenon::pacs::core::dicom_dataset > & results ) const

inlinenodiscardprivate

Format results as JSON.

Definition at line 155 of file result_formatter.h.

                                                                     {
        using namespace kcenon::pacs::core;
        std::ostringstream oss;
 
        oss << "{\n";
        oss << "  \"queryLevel\": \"" << kcenon::pacs::services::to_string(level_) << "\",\n";
        oss << "  \"resultCount\": " << results.size() << ",\n";
        oss << "  \"results\": [\n";
 
        auto columns = get_columns_for_level();
 
        for (size_t i = 0; i < results.size(); ++i) {
            const auto& result = results[i];
            oss << "    {\n";
 
            for (size_t j = 0; j < columns.size(); ++j) {
                auto value = get_tag_value(result, columns[j].tag);
                oss << "      \"" << columns[j].json_key << "\": \""
                    << escape_json(value) << "\"";
                if (j < columns.size() - 1) {
                    oss << ",";
                }
                oss << "\n";
            }
 
            oss << "    }";
            if (i < results.size() - 1) {
                oss << ",";
            }
            oss << "\n";
        }
 
        oss << "  ]\n";
        oss << "}\n";
 
        return oss.str();
    }

References escape_json(), get_columns_for_level(), get_tag_value(), level_, and kcenon::pacs::services::to_string().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

format_table()

std::string query_scu::result_formatter::format_table ( const std::vector< kcenon::pacs::core::dicom_dataset > & results ) const

inlinenodiscardprivate

Format results as a human-readable table.

Definition at line 86 of file result_formatter.h.

                                                                     {
        using namespace kcenon::pacs::core;
        std::ostringstream oss;
 
        if (results.empty()) {
            oss << "No results found.\n";
            return oss.str();
        }
 
        // Define columns based on query level
        auto columns = get_columns_for_level();
 
        // Calculate column widths
        std::vector<size_t> widths;
        widths.reserve(columns.size());
        for (const auto& col : columns) {
            widths.push_back(col.header.length());
        }
 
        // Update widths based on data
        for (const auto& result : results) {
            for (size_t i = 0; i < columns.size(); ++i) {
                auto value = get_tag_value(result, columns[i].tag);
                widths[i] = std::max(widths[i], value.length());
            }
        }
 
        // Cap widths at reasonable maximum
        for (auto& w : widths) {
            w = std::min(w, size_t(40));
        }
 
        // Print header
        oss << "\n=== Query Results (" << results.size() << " "
            << kcenon::pacs::services::to_string(level_) << "(s)) ===\n\n";
 
        // Print column headers
        for (size_t i = 0; i < columns.size(); ++i) {
            oss << std::left << std::setw(static_cast<int>(widths[i] + 2))
                << columns[i].header;
        }
        oss << "\n";
 
        // Print separator
        for (size_t i = 0; i < columns.size(); ++i) {
            oss << std::string(widths[i], '-') << "  ";
        }
        oss << "\n";
 
        // Print data rows
        for (const auto& result : results) {
            for (size_t i = 0; i < columns.size(); ++i) {
                auto value = get_tag_value(result, columns[i].tag);
                if (value.length() > widths[i]) {
                    value = value.substr(0, widths[i] - 3) + "...";
                }
                oss << std::left << std::setw(static_cast<int>(widths[i] + 2))
                    << value;
            }
            oss << "\n";
        }
 
        return oss.str();
    }

References get_columns_for_level(), get_tag_value(), level_, and kcenon::pacs::services::to_string().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

get_columns_for_level()

std::vector< column_def > query_scu::result_formatter::get_columns_for_level ( ) const

inlinenodiscardprivate

Get columns appropriate for the query level.

Definition at line 240 of file result_formatter.h.

                                                                      {
        using namespace kcenon::pacs::core;
        std::vector<column_def> columns;
 
        // Patient level columns (always included)
        columns.push_back({"Patient Name", tags::patient_name, "patientName"});
        columns.push_back({"Patient ID", tags::patient_id, "patientId"});
 
        if (level_ == query_level::patient) {
            columns.push_back({"Birth Date", tags::patient_birth_date, "birthDate"});
            columns.push_back({"Sex", tags::patient_sex, "sex"});
            return columns;
        }
 
        // Study level columns
        columns.push_back({"Study Date", tags::study_date, "studyDate"});
        columns.push_back({"Accession #", tags::accession_number, "accessionNumber"});
        columns.push_back({"Description", tags::study_description, "studyDescription"});
 
        if (level_ == query_level::study) {
            columns.push_back({"Modalities", tags::modalities_in_study, "modalities"});
            columns.push_back({"Study UID", tags::study_instance_uid, "studyInstanceUid"});
            return columns;
        }
 
        // Series level columns
        columns.push_back({"Modality", tags::modality, "modality"});
        columns.push_back({"Series #", tags::series_number, "seriesNumber"});
        columns.push_back({"Series Desc", tags::series_description, "seriesDescription"});
 
        if (level_ == query_level::series) {
            columns.push_back({"Series UID", tags::series_instance_uid, "seriesInstanceUid"});
            return columns;
        }
 
        // Instance level columns
        columns.push_back({"Instance #", tags::instance_number, "instanceNumber"});
        columns.push_back({"SOP Class", tags::sop_class_uid, "sopClassUid"});
        columns.push_back({"SOP Instance UID", tags::sop_instance_uid, "sopInstanceUid"});
 
        return columns;
    }

References level_.

Referenced by format_csv(), format_json(), and format_table().

Here is the caller graph for this function:

get_tag_value()

static std::string query_scu::result_formatter::get_tag_value ( const kcenon::pacs::core::dicom_dataset & ds, kcenon::pacs::core::dicom_tag tag )

inlinestaticnodiscardprivate

Get tag value from dataset as string.

Definition at line 286 of file result_formatter.h.

                                     {
        return ds.get_string(tag);
    }

References kcenon::pacs::core::dicom_dataset::get_string().

Referenced by format_csv(), format_json(), and format_table().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

format_

output_format query_scu::result_formatter::format_

private

Definition at line 342 of file result_formatter.h.

Referenced by format().

level_

query_level query_scu::result_formatter::level_

private

Definition at line 343 of file result_formatter.h.

Referenced by format_json(), format_table(), and get_columns_for_level().

---

The documentation for this class was generated from the following file:

• examples/query_scu/result_formatter.h