kcenon::pacs::client Namespace Reference

Classes
class	job_manager
struct	job_manager_config
	Configuration for the job manager. More...
struct	job_progress
	Progress tracking for a job. More...
struct	job_record
	Complete job record with all metadata. More...
struct	node_manager_config
	Configuration for the remote node manager. More...
struct	node_statistics
	Statistics for a remote node. More...
struct	prefetch_history
	History record for a single prefetch operation. More...
class	prefetch_manager
struct	prefetch_manager_config
	Configuration for the prefetch manager. More...
struct	prefetch_repositories
struct	prefetch_result
	Result of a prefetch operation. More...
struct	prefetch_rule
	Rule defining when and how to prefetch DICOM data. More...
struct	prefetch_rule_statistics
	Statistics for a prefetch rule. More...
struct	queue_entry
struct	remote_node
class	remote_node_manager
struct	routing_action
	Action to perform when a routing rule matches. More...
struct	routing_condition
	A single condition for routing rule evaluation. More...
class	routing_manager
struct	routing_manager_config
	Configuration for the routing manager. More...
struct	routing_rule
	A complete routing rule with conditions and actions. More...
struct	routing_statistics
	Statistics for routing operations. More...
struct	routing_test_result
	Result of testing rules against a dataset (dry run) More...
struct	sync_config
	Configuration for a synchronization task. More...
struct	sync_conflict
	Represents a conflict detected during synchronization. More...
struct	sync_history
	Historical record of a sync operation. More...
class	sync_manager
struct	sync_manager_config
	Configuration for the sync manager. More...
struct	sync_repositories
struct	sync_result
	Result of a synchronization operation. More...
struct	sync_statistics
	Aggregate statistics for synchronization operations. More...
struct	tls_config
	TLS configuration for secure DICOM connections. More...

Typedefs
using	job_progress_callback
	Callback for job progress updates.
using	job_completion_callback
	Callback for job completion.
using	node_status_callback = std::function<void(std::string_view node_id, node_status status)>
	Callback function type for node status changes.
using	routing_event_callback
	Callback type for routing events.
using	sync_progress_callback
	Callback for sync progress updates.
using	sync_completion_callback
	Callback for sync completion.
using	sync_conflict_callback = std::function<void(const sync_conflict& conflict)>
	Callback for conflict detection.

Enumerations
enum class	job_type {   query , retrieve , store , export_ ,   import_ , prefetch , sync }
	Type of job operation. More...
enum class	job_status {   pending , queued , running , completed ,   failed , cancelled , paused }
	Current status of a job. More...
enum class	job_priority { low = 0 , normal = 1 , high = 2 , urgent = 3 }
	Priority level for job execution. More...
enum class	prefetch_trigger { worklist_match , prior_studies , scheduled_exam , manual }
	Trigger type for prefetch operations. More...
enum class	node_status {   unknown , online , offline , error ,   verifying }
	Status of a remote PACS node. More...
enum class	routing_field {   modality , station_ae , institution , department ,   referring_physician , study_description , series_description , body_part ,   patient_id_pattern , sop_class_uid }
	DICOM field to match in routing conditions. More...
enum class	sync_direction { pull , push , bidirectional }
	Direction of synchronization. More...
enum class	sync_conflict_type { missing_local , missing_remote , modified , count_mismatch }
	Type of synchronization conflict. More...
enum class	conflict_resolution { prefer_local , prefer_remote , prefer_newer }
	Strategy for resolving synchronization conflicts. More...

Functions
constexpr const char *	to_string (job_type type) noexcept
	Convert job_type to string representation.
job_type	job_type_from_string (std::string_view str) noexcept
	Parse job_type from string.
constexpr const char *	to_string (job_status status) noexcept
	Convert job_status to string representation.
job_status	job_status_from_string (std::string_view str) noexcept
	Parse job_status from string.
constexpr bool	is_terminal_status (job_status status) noexcept
	Check if job status is a terminal state.
constexpr const char *	to_string (job_priority priority) noexcept
	Convert job_priority to string representation.
job_priority	job_priority_from_string (std::string_view str) noexcept
	Parse job_priority from string.
job_priority	job_priority_from_int (int value) noexcept
	Parse job_priority from integer.
constexpr const char *	to_string (prefetch_trigger trigger) noexcept
	Convert prefetch_trigger to string representation.
prefetch_trigger	prefetch_trigger_from_string (std::string_view str) noexcept
	Parse prefetch_trigger from string.
constexpr const char *	to_string (node_status status) noexcept
	Convert node_status to string representation.
node_status	node_status_from_string (std::string_view str) noexcept
	Parse node_status from string.
constexpr const char *	to_string (routing_field field) noexcept
	Convert routing_field to string representation.
routing_field	routing_field_from_string (std::string_view str) noexcept
	Parse routing_field from string.
constexpr const char *	to_string (sync_direction direction) noexcept
	Convert sync_direction to string representation.
sync_direction	sync_direction_from_string (std::string_view str) noexcept
	Parse sync_direction from string.
constexpr const char *	to_string (sync_conflict_type type) noexcept
	Convert sync_conflict_type to string representation.
sync_conflict_type	sync_conflict_type_from_string (std::string_view str) noexcept
	Parse sync_conflict_type from string.
constexpr const char *	to_string (conflict_resolution resolution) noexcept
	Convert conflict_resolution to string representation.
conflict_resolution	conflict_resolution_from_string (std::string_view str) noexcept
	Parse conflict_resolution from string.

Typedef Documentation

job_completion_callback

using kcenon::pacs::client::job_completion_callback

Initial value:

 std::function<void(
    const std::string& job_id,
    const job_record& record)>

Callback for job completion.

Parameters

job_id	The ID of the job
record	Final job record

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/job_manager.h.

Definition at line 395 of file job_types.h.

job_progress_callback

using kcenon::pacs::client::job_progress_callback

Initial value:

 std::function<void(
    const std::string& job_id,
    const job_progress& progress)>

Callback for job progress updates.

Parameters

job_id	The ID of the job
progress	Current progress information

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/job_manager.h.

Definition at line 385 of file job_types.h.

node_status_callback

using kcenon::pacs::client::node_status_callback = std::function<void(std::string_view node_id, node_status status)>

Callback function type for node status changes.

Invoked when a node's status changes (e.g., online -> offline).

Parameters

node_id	The ID of the node whose status changed
status	The new status

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node.h, and /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 227 of file remote_node.h.

routing_event_callback

using kcenon::pacs::client::routing_event_callback

Initial value:

 std::function<void(
    const std::string& rule_id,
    const std::string& instance_uid,
    const std::vector<routing_action>& triggered_actions)>

Callback type for routing events.

Parameters

rule_id	The ID of the rule that triggered
instance_uid	The SOP Instance UID being routed
triggered_actions	The actions that will be executed

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/routing_manager.h.

Definition at line 260 of file routing_types.h.

sync_completion_callback

using kcenon::pacs::client::sync_completion_callback

Initial value:

 std::function<void(
    const std::string& config_id,
    const sync_result& result)>

Callback for sync completion.

Parameters

config_id	The ID of the sync config
result	Final sync result

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/sync_manager.h.

Definition at line 361 of file sync_types.h.

sync_conflict_callback

using kcenon::pacs::client::sync_conflict_callback = std::function<void(const sync_conflict& conflict)>

Callback for conflict detection.

Parameters

conflict

The detected conflict

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/sync_manager.h.

Definition at line 370 of file sync_types.h.

sync_progress_callback

using kcenon::pacs::client::sync_progress_callback

Initial value:

 std::function<void(
    const std::string& config_id,
    size_t studies_synced,
    size_t studies_total)>

Callback for sync progress updates.

Parameters

config_id	The ID of the sync config
studies_synced	Number of studies synced so far
studies_total	Total studies to sync

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/sync_manager.h.

Definition at line 350 of file sync_types.h.

Enumeration Type Documentation

conflict_resolution

enum class kcenon::pacs::client::conflict_resolution

strong

Strategy for resolving synchronization conflicts.

Enumerator
prefer_local	Keep local version.
prefer_remote	Use remote version.
prefer_newer	Use the newer version based on timestamp.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/sync_manager.h.

Definition at line 121 of file sync_types.h.

                               {
    prefer_local,   
    prefer_remote,  
    prefer_newer    
};

job_priority

enum class kcenon::pacs::client::job_priority

strong

Priority level for job execution.

Higher priority jobs are executed before lower priority ones.

Enumerator
low	Background operations.
normal	Standard priority.
high	User-requested operations.
urgent	Critical operations.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/job_manager.h.

Definition at line 154 of file job_types.h.

                        {
    low = 0,     
    normal = 1,  
    high = 2,    
    urgent = 3   
};

job_status

enum class kcenon::pacs::client::job_status

strong

Current status of a job.

Enumerator
pending	Job created but not yet queued.
queued	Job is in the execution queue.
running	Job is currently executing.
completed	Job completed successfully.
failed	Job failed with error.
cancelled	Job was cancelled by user.
paused	Job is paused.

Definition at line 90 of file job_types.h.

                      {
    pending,    
    queued,     
    running,    
    completed,  
    failed,     
    cancelled,  
    paused      
};

job_type

enum class kcenon::pacs::client::job_type

strong

Type of job operation.

Enumerator
query	C-FIND operation.
retrieve	C-MOVE/C-GET operation.
store	C-STORE operation.
export_	Export to external system.
import_	Import from external source.
prefetch	Prefetch prior studies.
sync	Synchronization.

Definition at line 39 of file job_types.h.

                    {
    query,      
    retrieve,   
    store,      
    export_,    
    import_,    
    prefetch,   
    sync        
};

node_status

enum class kcenon::pacs::client::node_status

strong

Status of a remote PACS node.

Represents the current connectivity and health status of a remote node.

Enumerator
unknown	Status not yet determined.
online	Node is responding to C-ECHO.
offline	Node is not responding.
error	Node returned an error.
verifying	Verification in progress.

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node.h, and /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node_manager.h.

Definition at line 51 of file remote_node.h.

                       {
    unknown,     
    online,      
    offline,     
    error,       
    verifying    
};

prefetch_trigger

enum class kcenon::pacs::client::prefetch_trigger

strong

Trigger type for prefetch operations.

Enumerator
worklist_match	Triggered by worklist entry.
prior_studies	Fetch prior studies for patient.
scheduled_exam	Based on scheduled procedure.
manual	Manual request.

Definition at line 34 of file prefetch_types.h.

                            {
    worklist_match,  
    prior_studies,   
    scheduled_exam,  
    manual           
};

routing_field

enum class kcenon::pacs::client::routing_field

strong

DICOM field to match in routing conditions.

These fields map to standard DICOM attributes that can be used for routing decisions.

Enumerator
modality	(0008,0060) Modality - CT, MR, US, etc.
station_ae	(0008,1010) Station Name or calling AE
institution	(0008,0080) Institution Name
department	(0008,1040) Institutional Department Name
referring_physician	(0008,0090) Referring Physician's Name
study_description	(0008,1030) Study Description
series_description	(0008,103E) Series Description
body_part	(0018,0015) Body Part Examined
patient_id_pattern	(0010,0020) Patient ID (pattern matching)
sop_class_uid	(0008,0016) SOP Class UID

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/routing_manager.h.

Definition at line 41 of file routing_types.h.

                         {
    modality,              
    station_ae,            
    institution,           
    department,            
    referring_physician,   
    study_description,     
    series_description,    
    body_part,             
    patient_id_pattern,    
    sop_class_uid          
};

sync_conflict_type

enum class kcenon::pacs::client::sync_conflict_type

strong

Type of synchronization conflict.

Enumerator
missing_local	Study exists on remote but not locally.
missing_remote	Study exists locally but not on remote.
modified	Study modified on both sides.
count_mismatch	Instance counts differ.

Definition at line 78 of file sync_types.h.

                              {
    missing_local,   
    missing_remote,  
    modified,        
    count_mismatch   
};

sync_direction

enum class kcenon::pacs::client::sync_direction

strong

Direction of synchronization.

Enumerator
pull	Pull from remote to local.
push	Push from local to remote.
bidirectional	Both directions.

Definition at line 38 of file sync_types.h.

                          {
    pull,          
    push,          
    bidirectional  
};

Function Documentation

conflict_resolution_from_string()

conflict_resolution kcenon::pacs::client::conflict_resolution_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse conflict_resolution from string.

Parameters

str	The string to parse

Returns

Parsed resolution, or prefer_remote if invalid

Definition at line 147 of file sync_types.h.

                                 {
    if (str == "prefer_local") return conflict_resolution::prefer_local;
    if (str == "prefer_remote") return conflict_resolution::prefer_remote;
    if (str == "prefer_newer") return conflict_resolution::prefer_newer;
    return conflict_resolution::prefer_remote;
}

References prefer_local, prefer_newer, and prefer_remote.

Referenced by kcenon::pacs::storage::sync_repository::parse_conflict_row().

Here is the caller graph for this function:

is_terminal_status()

bool kcenon::pacs::client::is_terminal_status ( job_status status )

nodiscardconstexprnoexcept

Check if job status is a terminal state.

Parameters

status

The status to check

Returns

true if the job has finished (completed, failed, or cancelled)

Definition at line 139 of file job_types.h.

                                                                            {
    return status == job_status::completed ||
           status == job_status::failed ||
           status == job_status::cancelled;
}

References cancelled, completed, and failed.

Referenced by kcenon::pacs::client::job_record::can_cancel(), kcenon::pacs::client::job_record::is_finished(), and kcenon::pacs::client::job_manager::impl::update_job_status().

Here is the caller graph for this function:

job_priority_from_int()

job_priority kcenon::pacs::client::job_priority_from_int ( int value )

inlinenodiscardnoexcept

Parse job_priority from integer.

Parameters

value

The integer value (0-3)

Returns

Parsed priority, or normal if out of range

Definition at line 194 of file job_types.h.

                                                                            {
    if (value <= 0) return job_priority::low;
    if (value == 1) return job_priority::normal;
    if (value == 2) return job_priority::high;
    if (value >= 3) return job_priority::urgent;
    return job_priority::normal;
}

References high, low, normal, and urgent.

job_priority_from_string()

job_priority kcenon::pacs::client::job_priority_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse job_priority from string.

Parameters

str	The string to parse

Returns

Parsed priority, or normal if invalid

Definition at line 181 of file job_types.h.

                                                                                        {
    if (str == "low") return job_priority::low;
    if (str == "normal") return job_priority::normal;
    if (str == "high") return job_priority::high;
    if (str == "urgent") return job_priority::urgent;
    return job_priority::normal;
}

References high, low, normal, and urgent.

Referenced by kcenon::pacs::storage::routing_repository::deserialize_actions(), and kcenon::pacs::web::endpoints::register_jobs_endpoints_impl().

Here is the caller graph for this function:

job_status_from_string()

job_status kcenon::pacs::client::job_status_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse job_status from string.

Parameters

str	The string to parse

Returns

Parsed status, or pending if invalid

Definition at line 123 of file job_types.h.

                                                                                    {
    if (str == "pending") return job_status::pending;
    if (str == "queued") return job_status::queued;
    if (str == "running") return job_status::running;
    if (str == "completed") return job_status::completed;
    if (str == "failed") return job_status::failed;
    if (str == "cancelled") return job_status::cancelled;
    if (str == "paused") return job_status::paused;
    return job_status::pending;
}

References cancelled, completed, failed, paused, pending, queued, and running.

Referenced by kcenon::pacs::web::endpoints::register_jobs_endpoints_impl().

Here is the caller graph for this function:

job_type_from_string()

job_type kcenon::pacs::client::job_type_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse job_type from string.

Parameters

str	The string to parse

Returns

Parsed type, or query if invalid

Definition at line 72 of file job_types.h.

                                                                                {
    if (str == "query") return job_type::query;
    if (str == "retrieve") return job_type::retrieve;
    if (str == "store") return job_type::store;
    if (str == "export") return job_type::export_;
    if (str == "import") return job_type::import_;
    if (str == "prefetch") return job_type::prefetch;
    if (str == "sync") return job_type::sync;
    return job_type::query;
}

References export_, import_, prefetch, query, retrieve, store, and sync.

Referenced by kcenon::pacs::web::endpoints::register_jobs_endpoints_impl().

Here is the caller graph for this function:

node_status_from_string()

node_status kcenon::pacs::client::node_status_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse node_status from string.

Parameters

str	The string to parse

Returns

Parsed status, or unknown if invalid

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node.h.

Definition at line 80 of file remote_node.h.

                                                                                      {
    if (str == "online") return node_status::online;
    if (str == "offline") return node_status::offline;
    if (str == "error") return node_status::error;
    if (str == "verifying") return node_status::verifying;
    return node_status::unknown;
}

References error, offline, online, unknown, and verifying.

Referenced by kcenon::pacs::storage::node_repository::parse_row(), and kcenon::pacs::web::endpoints::register_remote_nodes_endpoints_impl().

Here is the caller graph for this function:

prefetch_trigger_from_string()

prefetch_trigger kcenon::pacs::client::prefetch_trigger_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse prefetch_trigger from string.

Parameters

str	The string to parse

Returns

Parsed trigger, or manual if invalid

Definition at line 61 of file prefetch_types.h.

                                 {
    if (str == "worklist_match") return prefetch_trigger::worklist_match;
    if (str == "prior_studies") return prefetch_trigger::prior_studies;
    if (str == "scheduled_exam") return prefetch_trigger::scheduled_exam;
    if (str == "manual") return prefetch_trigger::manual;
    return prefetch_trigger::manual;
}

References manual, prior_studies, scheduled_exam, and worklist_match.

routing_field_from_string()

routing_field kcenon::pacs::client::routing_field_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse routing_field from string.

Parameters

str	The string to parse

Returns

Parsed field, or modality if invalid

Definition at line 80 of file routing_types.h.

                                 {
    if (str == "modality") return routing_field::modality;
    if (str == "station_ae") return routing_field::station_ae;
    if (str == "institution") return routing_field::institution;
    if (str == "department") return routing_field::department;
    if (str == "referring_physician") return routing_field::referring_physician;
    if (str == "study_description") return routing_field::study_description;
    if (str == "series_description") return routing_field::series_description;
    if (str == "body_part") return routing_field::body_part;
    if (str == "patient_id_pattern") return routing_field::patient_id_pattern;
    if (str == "sop_class_uid") return routing_field::sop_class_uid;
    return routing_field::modality;
}

References body_part, department, institution, modality, patient_id_pattern, referring_physician, series_description, sop_class_uid, station_ae, and study_description.

Referenced by kcenon::pacs::storage::routing_repository::deserialize_conditions().

Here is the caller graph for this function:

sync_conflict_type_from_string()

sync_conflict_type kcenon::pacs::client::sync_conflict_type_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse sync_conflict_type from string.

Parameters

str	The string to parse

Returns

Parsed type, or missing_local if invalid

Definition at line 105 of file sync_types.h.

                                 {
    if (str == "missing_local") return sync_conflict_type::missing_local;
    if (str == "missing_remote") return sync_conflict_type::missing_remote;
    if (str == "modified") return sync_conflict_type::modified;
    if (str == "count_mismatch") return sync_conflict_type::count_mismatch;
    return sync_conflict_type::missing_local;
}

References count_mismatch, missing_local, missing_remote, and modified.

Referenced by kcenon::pacs::storage::sync_repository::parse_conflict_row().

Here is the caller graph for this function:

sync_direction_from_string()

sync_direction kcenon::pacs::client::sync_direction_from_string ( std::string_view str )

inlinenodiscardnoexcept

Parse sync_direction from string.

Parameters

str	The string to parse

Returns

Parsed direction, or pull if invalid

Definition at line 63 of file sync_types.h.

                                 {
    if (str == "pull") return sync_direction::pull;
    if (str == "push") return sync_direction::push;
    if (str == "bidirectional") return sync_direction::bidirectional;
    return sync_direction::pull;
}

References bidirectional, pull, and push.

Referenced by kcenon::pacs::storage::sync_repository::parse_config_row().

Here is the caller graph for this function:

to_string() [1/9]

const char * kcenon::pacs::client::to_string ( conflict_resolution resolution )

nodiscardconstexprnoexcept

Convert conflict_resolution to string representation.

Parameters

resolution

The resolution to convert

Returns

String representation of the resolution

Definition at line 132 of file sync_types.h.

                                             {
    switch (resolution) {
        case conflict_resolution::prefer_local: return "prefer_local";
        case conflict_resolution::prefer_remote: return "prefer_remote";
        case conflict_resolution::prefer_newer: return "prefer_newer";
        default: return "unknown";
    }
}

References prefer_local, prefer_newer, and prefer_remote.

to_string() [2/9]

const char * kcenon::pacs::client::to_string ( job_priority priority )

nodiscardconstexprnoexcept

Convert job_priority to string representation.

Parameters

priority

The priority to convert

Returns

String representation of the priority

Definition at line 166 of file job_types.h.

                                                                              {
    switch (priority) {
        case job_priority::low: return "low";
        case job_priority::normal: return "normal";
        case job_priority::high: return "high";
        case job_priority::urgent: return "urgent";
        default: return "unknown";
    }
}

References high, low, normal, and urgent.

to_string() [3/9]

const char * kcenon::pacs::client::to_string ( job_status status )

nodiscardconstexprnoexcept

Convert job_status to string representation.

Parameters

status

The status to convert

Returns

String representation of the status

Definition at line 105 of file job_types.h.

                                                                          {
    switch (status) {
        case job_status::pending: return "pending";
        case job_status::queued: return "queued";
        case job_status::running: return "running";
        case job_status::completed: return "completed";
        case job_status::failed: return "failed";
        case job_status::cancelled: return "cancelled";
        case job_status::paused: return "paused";
        default: return "unknown";
    }
}

References cancelled, completed, failed, paused, pending, queued, and running.

to_string() [4/9]

const char * kcenon::pacs::client::to_string ( job_type type )

nodiscardconstexprnoexcept

Convert job_type to string representation.

Parameters

type	The type to convert

Returns

String representation of the type

Examples

/home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/client/remote_node.h.

Definition at line 54 of file job_types.h.

                                                                      {
    switch (type) {
        case job_type::query: return "query";
        case job_type::retrieve: return "retrieve";
        case job_type::store: return "store";
        case job_type::export_: return "export";
        case job_type::import_: return "import";
        case job_type::prefetch: return "prefetch";
        case job_type::sync: return "sync";
        default: return "unknown";
    }
}

References export_, import_, prefetch, query, retrieve, store, and sync.

Referenced by kcenon::pacs::client::job_manager::cancel_job(), kcenon::pacs::client::job_manager::impl::complete_job(), kcenon::pacs::storage::node_repository::find_by_status(), kcenon::pacs::storage::job_repository::find_jobs(), kcenon::pacs::storage::prefetch_repository::find_rules(), kcenon::pacs::client::job_manager::pause_job(), kcenon::pacs::web::endpoints::register_remote_nodes_endpoints_impl(), kcenon::pacs::client::sync_manager::resolve_conflict(), kcenon::pacs::client::job_manager::resume_job(), kcenon::pacs::client::job_manager::retry_job(), kcenon::pacs::storage::job_repository::save(), kcenon::pacs::storage::prefetch_repository::save_rule(), kcenon::pacs::storage::routing_repository::serialize_actions(), kcenon::pacs::storage::routing_repository::serialize_conditions(), kcenon::pacs::client::job_manager::start_job(), kcenon::pacs::storage::node_repository::update_status(), kcenon::pacs::storage::node_repository::upsert(), and kcenon::pacs::client::job_manager::impl::worker_loop().

Here is the caller graph for this function:

to_string() [5/9]

const char * kcenon::pacs::client::to_string ( node_status status )

nodiscardconstexprnoexcept

Convert node_status to string representation.

Parameters

status

The status to convert

Returns

String representation of the status

Definition at line 64 of file remote_node.h.

                                                                           {
    switch (status) {
        case node_status::unknown: return "unknown";
        case node_status::online: return "online";
        case node_status::offline: return "offline";
        case node_status::error: return "error";
        case node_status::verifying: return "verifying";
        default: return "unknown";
    }
}

References error, offline, online, unknown, and verifying.

to_string() [6/9]

const char * kcenon::pacs::client::to_string ( prefetch_trigger trigger )

nodiscardconstexprnoexcept

Convert prefetch_trigger to string representation.

Parameters

trigger

The trigger to convert

Returns

String representation of the trigger

Definition at line 46 of file prefetch_types.h.

                                                                                 {
    switch (trigger) {
        case prefetch_trigger::worklist_match: return "worklist_match";
        case prefetch_trigger::prior_studies: return "prior_studies";
        case prefetch_trigger::scheduled_exam: return "scheduled_exam";
        case prefetch_trigger::manual: return "manual";
        default: return "unknown";
    }
}

References manual, prior_studies, scheduled_exam, and worklist_match.

to_string() [7/9]

const char * kcenon::pacs::client::to_string ( routing_field field )

nodiscardconstexprnoexcept

Convert routing_field to string representation.

Parameters

field

The field to convert

Returns

String representation of the field

Definition at line 59 of file routing_types.h.

                                                                            {
    switch (field) {
        case routing_field::modality: return "modality";
        case routing_field::station_ae: return "station_ae";
        case routing_field::institution: return "institution";
        case routing_field::department: return "department";
        case routing_field::referring_physician: return "referring_physician";
        case routing_field::study_description: return "study_description";
        case routing_field::series_description: return "series_description";
        case routing_field::body_part: return "body_part";
        case routing_field::patient_id_pattern: return "patient_id_pattern";
        case routing_field::sop_class_uid: return "sop_class_uid";
        default: return "unknown";
    }
}

References body_part, department, institution, modality, patient_id_pattern, referring_physician, series_description, sop_class_uid, station_ae, and study_description.

to_string() [8/9]

const char * kcenon::pacs::client::to_string ( sync_conflict_type type )

nodiscardconstexprnoexcept

Convert sync_conflict_type to string representation.

Parameters

type	The type to convert

Returns

String representation of the type

Definition at line 90 of file sync_types.h.

                                                                                {
    switch (type) {
        case sync_conflict_type::missing_local: return "missing_local";
        case sync_conflict_type::missing_remote: return "missing_remote";
        case sync_conflict_type::modified: return "modified";
        case sync_conflict_type::count_mismatch: return "count_mismatch";
        default: return "unknown";
    }
}

References count_mismatch, missing_local, missing_remote, and modified.

to_string() [9/9]

const char * kcenon::pacs::client::to_string ( sync_direction direction )

nodiscardconstexprnoexcept

Convert sync_direction to string representation.

Parameters

direction

The direction to convert

Returns

String representation of the direction

Definition at line 49 of file sync_types.h.

                                                                                 {
    switch (direction) {
        case sync_direction::pull: return "pull";
        case sync_direction::push: return "push";
        case sync_direction::bidirectional: return "bidirectional";
        default: return "unknown";
    }
}

References bidirectional, pull, and push.