worklist_cli::worklist_result_formatter Class Reference

Result formatter for worklist query results. More...

#include <worklist_result_formatter.h>

Collaboration diagram for worklist_cli::worklist_result_formatter:

Classes
struct	worklist_item
	Worklist item data extracted for display. More...

Public Member Functions
	worklist_result_formatter (output_format format)
	Construct formatter with output format.
std::string	format (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format worklist results.

Private Member Functions
worklist_item	extract_item (const kcenon::pacs::core::dicom_dataset &ds) const
	Extract worklist item data from dataset.
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::string	format_xml (const std::vector< kcenon::pacs::core::dicom_dataset > &results) const
	Format results as XML.

Static Private Member Functions
static std::string	truncate (const std::string &s, size_t max_len)
	Truncate string to max length.
static std::string	format_date (const std::string &date)
	Format DICOM date (YYYYMMDD) for display.
static std::string	format_time (const std::string &time)
	Format DICOM time (HHMMSS) for display.
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.
static std::string	escape_xml (const std::string &s)
	Escape string for XML output.

Private Attributes
output_format	format_

Detailed Description

Result formatter for worklist query results.

Formats MWL C-FIND query results for display in different output formats. Handles the complexity of extracting data from the Scheduled Procedure Step Sequence.

Examples

worklist_scu/main.cpp.

Definition at line 55 of file worklist_result_formatter.h.

Constructor & Destructor Documentation

worklist_result_formatter()

worklist_cli::worklist_result_formatter::worklist_result_formatter ( output_format format )

inlineexplicit

Construct formatter with output format.

Parameters

format

The output format to use

Definition at line 61 of file worklist_result_formatter.h.

        : format_(format) {}

Member Function Documentation

escape_csv()

static std::string worklist_cli::worklist_result_formatter::escape_csv ( const std::string & s )

inlinestaticnodiscardprivate

Escape string for CSV output.

Definition at line 411 of file worklist_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 worklist_cli::worklist_result_formatter::escape_json ( const std::string & s )

inlinestaticnodiscardprivate

Escape string for JSON output.

Definition at line 381 of file worklist_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:

escape_xml()

static std::string worklist_cli::worklist_result_formatter::escape_xml ( const std::string & s )

inlinestaticnodiscardprivate

Escape string for XML output.

Definition at line 431 of file worklist_result_formatter.h.

                                                                  {
        std::string result;
        result.reserve(s.length());
        for (char c : s) {
            switch (c) {
                case '&': result += "&"; break;
                case '<': result += "&lt;"; break;
                case '>': result += "&gt;"; break;
                case '"': result += "&quot;"; break;
                case '\'': result += "&apos;"; break;
                default: result += c;
            }
        }
        return result;
    }

Referenced by format_xml().

Here is the caller graph for this function:

extract_item()

worklist_item worklist_cli::worklist_result_formatter::extract_item ( const kcenon::pacs::core::dicom_dataset & ds ) const

inlinenodiscardprivate

Extract worklist item data from dataset.

Note

This implementation uses a flat dataset structure without nested sequences. The Scheduled Procedure Step attributes are extracted directly from the main dataset.

Definition at line 116 of file worklist_result_formatter.h.

                                                     {
        using namespace kcenon::pacs::core;
 
        worklist_item item;
 
        // Patient demographics
        item.patient_name = ds.get_string(tags::patient_name);
        item.patient_id = ds.get_string(tags::patient_id);
        item.patient_birth_date = ds.get_string(tags::patient_birth_date);
        item.patient_sex = ds.get_string(tags::patient_sex);
 
        // Study-level attributes
        item.accession_number = ds.get_string(tags::accession_number);
        item.study_uid = ds.get_string(tags::study_instance_uid);
        item.requested_procedure_id = ds.get_string(tags::requested_procedure_id);
 
        // Scheduled Procedure Step attributes (flat structure)
        item.scheduled_date = ds.get_string(tags::scheduled_procedure_step_start_date);
        item.scheduled_time = ds.get_string(tags::scheduled_procedure_step_start_time);
        item.modality = ds.get_string(tags::modality);
        item.station_ae = ds.get_string(tags::scheduled_station_ae_title);
        item.step_id = ds.get_string(tags::scheduled_procedure_step_id);
        item.step_description = ds.get_string(tags::scheduled_procedure_step_description);
 
        return item;
    }

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

format()

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

inlinenodiscard

Format worklist results.

Parameters

results

Vector of result datasets

Returns

Formatted string output

Examples

worklist_scu/main.cpp.

Definition at line 69 of file worklist_result_formatter.h.

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

References worklist_cli::csv, format_, format_csv(), format_json(), format_table(), format_xml(), worklist_cli::json, worklist_cli::table, and worklist_cli::xml.

Here is the call graph for this function:

format_csv()

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

inlinenodiscardprivate

Format results as CSV.

Definition at line 268 of file worklist_result_formatter.h.

                                                                     {
        std::ostringstream oss;
 
        // Header row
        oss << "PatientName,PatientID,BirthDate,Sex,"
            << "ScheduledDate,ScheduledTime,Modality,StationAE,"
            << "StepID,StepDescription,AccessionNumber,StudyUID,RequestedProcedureID\n";
 
        // Data rows
        for (const auto& r : results) {
            auto item = extract_item(r);
 
            oss << escape_csv(item.patient_name) << ","
                << escape_csv(item.patient_id) << ","
                << item.patient_birth_date << ","
                << item.patient_sex << ","
                << item.scheduled_date << ","
                << item.scheduled_time << ","
                << item.modality << ","
                << escape_csv(item.station_ae) << ","
                << escape_csv(item.step_id) << ","
                << escape_csv(item.step_description) << ","
                << escape_csv(item.accession_number) << ","
                << item.study_uid << ","
                << escape_csv(item.requested_procedure_id) << "\n";
        }
 
        return oss.str();
    }

References escape_csv(), and extract_item().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

format_date()

static std::string worklist_cli::worklist_result_formatter::format_date ( const std::string & date )

inlinestaticnodiscardprivate

Format DICOM date (YYYYMMDD) for display.

Definition at line 361 of file worklist_result_formatter.h.

                                                                      {
        if (date.length() == 8) {
            return date.substr(0, 4) + "-" + date.substr(4, 2) + "-" + date.substr(6, 2);
        }
        return date;
    }

Referenced by format_table().

Here is the caller graph for this function:

format_json()

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

inlinenodiscardprivate

Format results as JSON.

Definition at line 222 of file worklist_result_formatter.h.

                                                                     {
        std::ostringstream oss;
 
        oss << "{\n";
        oss << "  \"resultCount\": " << results.size() << ",\n";
        oss << "  \"worklistItems\": [\n";
 
        for (size_t i = 0; i < results.size(); ++i) {
            auto item = extract_item(results[i]);
 
            oss << "    {\n";
            oss << "      \"patient\": {\n";
            oss << "        \"name\": \"" << escape_json(item.patient_name) << "\",\n";
            oss << "        \"id\": \"" << escape_json(item.patient_id) << "\",\n";
            oss << "        \"birthDate\": \"" << item.patient_birth_date << "\",\n";
            oss << "        \"sex\": \"" << item.patient_sex << "\"\n";
            oss << "      },\n";
            oss << "      \"scheduledProcedureStep\": {\n";
            oss << "        \"startDate\": \"" << item.scheduled_date << "\",\n";
            oss << "        \"startTime\": \"" << item.scheduled_time << "\",\n";
            oss << "        \"modality\": \"" << item.modality << "\",\n";
            oss << "        \"stationAETitle\": \"" << escape_json(item.station_ae) << "\",\n";
            oss << "        \"stepId\": \"" << escape_json(item.step_id) << "\",\n";
            oss << "        \"description\": \"" << escape_json(item.step_description) << "\"\n";
            oss << "      },\n";
            oss << "      \"accessionNumber\": \"" << escape_json(item.accession_number) << "\",\n";
            oss << "      \"studyInstanceUid\": \"" << item.study_uid << "\",\n";
            oss << "      \"requestedProcedureId\": \"" << escape_json(item.requested_procedure_id) << "\"\n";
            oss << "    }";
 
            if (i < results.size() - 1) {
                oss << ",";
            }
            oss << "\n";
        }
 
        oss << "  ]\n";
        oss << "}\n";
 
        return oss.str();
    }

References escape_json(), and extract_item().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

format_table()

std::string worklist_cli::worklist_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 147 of file worklist_result_formatter.h.

                                                                     {
        std::ostringstream oss;
 
        if (results.empty()) {
            oss << "No worklist items found.\n";
            return oss.str();
        }
 
        // Extract all items
        std::vector<worklist_item> items;
        items.reserve(results.size());
        for (const auto& r : results) {
            items.push_back(extract_item(r));
        }
 
        // Define column widths
        size_t w_name = 20, w_id = 12, w_date = 10, w_time = 8;
        size_t w_mod = 6, w_station = 16, w_accession = 12, w_step = 12;
 
        // Update widths based on data
        for (const auto& item : items) {
            w_name = std::min(size_t(30), std::max(w_name, item.patient_name.length()));
            w_id = std::min(size_t(20), std::max(w_id, item.patient_id.length()));
            w_station = std::min(size_t(20), std::max(w_station, item.station_ae.length()));
            w_accession = std::min(size_t(20), std::max(w_accession, item.accession_number.length()));
            w_step = std::min(size_t(20), std::max(w_step, item.step_id.length()));
        }
 
        // Print header
        oss << "\n=== Worklist Results (" << results.size() << " scheduled procedure(s)) ===\n\n";
 
        // Print column headers
        oss << std::left
            << std::setw(static_cast<int>(w_name + 2)) << "Patient Name"
            << std::setw(static_cast<int>(w_id + 2)) << "Patient ID"
            << std::setw(static_cast<int>(w_date + 2)) << "Sched Date"
            << std::setw(static_cast<int>(w_time + 2)) << "Time"
            << std::setw(static_cast<int>(w_mod + 2)) << "Mod"
            << std::setw(static_cast<int>(w_station + 2)) << "Station AE"
            << std::setw(static_cast<int>(w_accession + 2)) << "Accession#"
            << std::setw(static_cast<int>(w_step + 2)) << "Step ID"
            << "\n";
 
        // Print separator
        oss << std::string(w_name, '-') << "  "
            << std::string(w_id, '-') << "  "
            << std::string(w_date, '-') << "  "
            << std::string(w_time, '-') << "  "
            << std::string(w_mod, '-') << "  "
            << std::string(w_station, '-') << "  "
            << std::string(w_accession, '-') << "  "
            << std::string(w_step, '-') << "  "
            << "\n";
 
        // Print data rows
        for (const auto& item : items) {
            oss << std::left
                << std::setw(static_cast<int>(w_name + 2)) << truncate(item.patient_name, w_name)
                << std::setw(static_cast<int>(w_id + 2)) << truncate(item.patient_id, w_id)
                << std::setw(static_cast<int>(w_date + 2)) << format_date(item.scheduled_date)
                << std::setw(static_cast<int>(w_time + 2)) << format_time(item.scheduled_time)
                << std::setw(static_cast<int>(w_mod + 2)) << item.modality
                << std::setw(static_cast<int>(w_station + 2)) << truncate(item.station_ae, w_station)
                << std::setw(static_cast<int>(w_accession + 2)) << truncate(item.accession_number, w_accession)
                << std::setw(static_cast<int>(w_step + 2)) << truncate(item.step_id, w_step)
                << "\n";
        }
 
        return oss.str();
    }

References extract_item(), format_date(), format_time(), and truncate().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

format_time()

static std::string worklist_cli::worklist_result_formatter::format_time ( const std::string & time )

inlinestaticnodiscardprivate

Format DICOM time (HHMMSS) for display.

Definition at line 371 of file worklist_result_formatter.h.

                                                                      {
        if (time.length() >= 4) {
            return time.substr(0, 2) + ":" + time.substr(2, 2);
        }
        return time;
    }

Referenced by format_table().

Here is the caller graph for this function:

format_xml()

std::string worklist_cli::worklist_result_formatter::format_xml ( const std::vector< kcenon::pacs::core::dicom_dataset > & results ) const

inlinenodiscardprivate

Format results as XML.

Definition at line 302 of file worklist_result_formatter.h.

                                                                     {
        std::ostringstream oss;
 
        oss << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n";
        oss << "<WorklistQueryResult>\n";
        oss << "  <ResultCount>" << results.size() << "</ResultCount>\n";
        oss << "  <WorklistItems>\n";
 
        for (size_t i = 0; i < results.size(); ++i) {
            auto item = extract_item(results[i]);
 
            oss << "    <WorklistItem index=\"" << (i + 1) << "\">\n";
 
            // Patient information
            oss << "      <Patient>\n";
            oss << "        <Name>" << escape_xml(item.patient_name) << "</Name>\n";
            oss << "        <ID>" << escape_xml(item.patient_id) << "</ID>\n";
            oss << "        <BirthDate>" << item.patient_birth_date << "</BirthDate>\n";
            oss << "        <Sex>" << item.patient_sex << "</Sex>\n";
            oss << "      </Patient>\n";
 
            // Scheduled Procedure Step
            oss << "      <ScheduledProcedureStep>\n";
            oss << "        <StartDate>" << item.scheduled_date << "</StartDate>\n";
            oss << "        <StartTime>" << item.scheduled_time << "</StartTime>\n";
            oss << "        <Modality>" << item.modality << "</Modality>\n";
            oss << "        <StationAETitle>" << escape_xml(item.station_ae) << "</StationAETitle>\n";
            oss << "        <StepID>" << escape_xml(item.step_id) << "</StepID>\n";
            oss << "        <Description>" << escape_xml(item.step_description) << "</Description>\n";
            oss << "      </ScheduledProcedureStep>\n";
 
            // Study information
            oss << "      <AccessionNumber>" << escape_xml(item.accession_number) << "</AccessionNumber>\n";
            oss << "      <StudyInstanceUID>" << item.study_uid << "</StudyInstanceUID>\n";
            oss << "      <RequestedProcedureID>" << escape_xml(item.requested_procedure_id) << "</RequestedProcedureID>\n";
 
            oss << "    </WorklistItem>\n";
        }
 
        oss << "  </WorklistItems>\n";
        oss << "</WorklistQueryResult>\n";
 
        return oss.str();
    }

References escape_xml(), and extract_item().

Referenced by format().

Here is the call graph for this function:

Here is the caller graph for this function:

truncate()

static std::string worklist_cli::worklist_result_formatter::truncate ( const std::string & s, size_t max_len )

inlinestaticnodiscardprivate

Truncate string to max length.

Definition at line 351 of file worklist_result_formatter.h.

                                                                                {
        if (s.length() <= max_len) {
            return s;
        }
        return s.substr(0, max_len - 3) + "...";
    }

Referenced by format_table().

Here is the caller graph for this function:

Member Data Documentation

format_

output_format worklist_cli::worklist_result_formatter::format_

private

Definition at line 447 of file worklist_result_formatter.h.

Referenced by format().

---

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

• examples/worklist_scu/worklist_result_formatter.h