Represents a DICOM Dataset (ordered collection of Data Elements) More...

#include <dicom_dataset.h>

Collaboration diagram for kcenon::pacs::core::dicom_dataset:

Public Types
using	storage_type = std::map<dicom_tag, dicom_element>
	Storage type for elements (ordered by tag)

using	iterator = storage_type::iterator
	Iterator type.

using	const_iterator = storage_type::const_iterator
	Const iterator type.

Public Member Functions
	dicom_dataset ()=default
	Default constructor - creates an empty dataset.

	dicom_dataset (const dicom_dataset &)=default
	Copy constructor.

	dicom_dataset (dicom_dataset &&) noexcept=default
	Move constructor.

auto	operator= (const dicom_dataset &) -> dicom_dataset &=default
	Copy assignment.

auto	operator= (dicom_dataset &&) noexcept -> dicom_dataset &=default
	Move assignment.

	~dicom_dataset ()=default
	Default destructor.

auto	contains (dicom_tag tag) const noexcept -> bool
	Check if the dataset contains an element with the given tag.

auto	get (dicom_tag tag) noexcept -> dicom_element *
	Get a pointer to the element with the given tag.

auto	get (dicom_tag tag) const noexcept -> const dicom_element *
	Get a const pointer to the element with the given tag.

auto	get_string (dicom_tag tag, std::string_view default_value="") const -> std::string
	Get the string value of an element.

template<typename T > requires std::is_arithmetic_v<T>
auto	get_numeric (dicom_tag tag) const -> std::optional< T >
	Get the numeric value of an element.

auto	has_sequence (dicom_tag tag) const noexcept -> bool
	Check if the dataset contains a sequence element with the given tag.

auto	get_sequence (dicom_tag tag) const noexcept -> const std::vector< dicom_dataset > *
	Get read-only access to sequence items for a given tag.

auto	get_sequence (dicom_tag tag) noexcept -> std::vector< dicom_dataset > *
	Get mutable access to sequence items for a given tag.

auto	get_or_create_sequence (dicom_tag tag) -> std::vector< dicom_dataset > &
	Insert or create a sequence element with the given tag.

auto	get_private_creator (dicom_tag private_data_tag) const -> std::optional< std::string >
	Get the Private Creator identification string for a private data element.

auto	get_private_block (std::string_view creator_id, uint16_t group) const -> std::vector< const dicom_element * >
	Get all private data elements belonging to a specific creator.

auto	set_private_element (std::string_view creator_id, uint16_t group, uint8_t element_offset, encoding::vr_type vr, std::string_view value) -> std::optional< dicom_tag >
	Insert a private data element with automatic creator management.

auto	remove_private_block (std::string_view creator_id, uint16_t group) -> size_t
	Remove all private data elements and their creator for a given creator.

auto	cleanup_orphaned_creators () -> size_t
	Remove orphaned Private Creator elements that have no data elements.

auto	validate_private_tags () const -> std::vector< dicom_tag >
	Validate private tag relationships in this dataset.

void	insert (dicom_element element)
	Insert or replace an element in the dataset.

void	set_string (dicom_tag tag, encoding::vr_type vr, std::string_view value)
	Set a string value for the given tag.

template<typename T > requires std::is_arithmetic_v<T>
void	set_numeric (dicom_tag tag, encoding::vr_type vr, T value)
	Set a numeric value for the given tag.

auto	remove (dicom_tag tag) -> bool
	Remove an element from the dataset.

void	clear () noexcept
	Remove all elements from the dataset.

auto	begin () noexcept -> iterator
	Get iterator to the first element.

auto	end () noexcept -> iterator
	Get iterator past the last element.

auto	begin () const noexcept -> const_iterator
	Get const iterator to the first element.

auto	end () const noexcept -> const_iterator
	Get const iterator past the last element.

auto	cbegin () const noexcept -> const_iterator
	Get const iterator to the first element.

auto	cend () const noexcept -> const_iterator
	Get const iterator past the last element.

auto	size () const noexcept -> size_t
	Get the number of elements in the dataset.

auto	empty () const noexcept -> bool
	Check if the dataset is empty.

auto	copy_with_tags (std::initializer_list< dicom_tag > tags) const -> dicom_dataset
	Create a copy containing only the specified tags.

auto	copy_with_tags (std::span< const dicom_tag > tags) const -> dicom_dataset
	Create a copy containing only the specified tags.

void	merge (const dicom_dataset &other)
	Merge elements from another dataset.

void	merge (dicom_dataset &&other)
	Merge elements from another dataset (move version)

Private Attributes
storage_type	elements_

Detailed Description

Represents a DICOM Dataset (ordered collection of Data Elements)

A DICOM Dataset is an ordered collection of Data Elements, where each element is uniquely identified by its tag. Elements are stored in ascending tag order as required by the DICOM standard.

Thread Safety: This class is NOT thread-safe. External synchronization is required for concurrent access.

Example:: dicom_dataset ds;

// Set string values

ds.set_string(tags::patient_name, encoding::vr_type::PN, "DOE^JOHN");

ds.set_string(tags::patient_id, encoding::vr_type::LO, "12345");

// Set numeric values

ds.set_numeric<uint16_t>(tags::rows, encoding::vr_type::US, 512);

// Access values

std::string name = ds.get_string(tags::patient_name);

uint16_t rows = ds.get_numeric<uint16_t>(tags::rows).value_or(0);

// Iterate over elements

for (const auto& [tag, element] : ds) {

std::cout << tag.to_string() << ": " << element.as_string() << "\n";

}

kcenon::pacs::core::dicom_dataset
Represents a DICOM Dataset (ordered collection of Data Elements)
Definition dicom_dataset.h:65

kcenon::pacs::core::dicom_dataset::set_numeric
void set_numeric(dicom_tag tag, encoding::vr_type vr, T value)
Set a numeric value for the given tag.
Definition dicom_dataset.h:448

kcenon::pacs::core::dicom_dataset::get_numeric
auto get_numeric(dicom_tag tag) const -> std::optional< T >
Get the numeric value of an element.
Definition dicom_dataset.h:433

kcenon::pacs::core::dicom_dataset::set_string
void set_string(dicom_tag tag, encoding::vr_type vr, std::string_view value)
Set a string value for the given tag.
Definition dicom_dataset.cpp:286

kcenon::pacs::core::dicom_dataset::get_string
auto get_string(dicom_tag tag, std::string_view default_value="") const -> std::string
Get the string value of an element.
Definition dicom_dataset.cpp:42

kcenon::pacs::core::tags::patient_id
constexpr dicom_tag patient_id
Patient ID.
Definition dicom_tag_constants.h:238

kcenon::pacs::core::tags::rows
constexpr dicom_tag rows
Rows.
Definition dicom_tag_constants.h:330

kcenon::pacs::core::tags::patient_name
constexpr dicom_tag patient_name
Patient's Name.
Definition dicom_tag_constants.h:235

kcenon::pacs::encoding::vr_type::LO
@ LO
Long String (64 chars max)

kcenon::pacs::encoding::vr_type::US
@ US
Unsigned Short (2 bytes)

kcenon::pacs::encoding::vr_type::PN
@ PN
Person Name (64 chars max per component group)

name
std::string_view name
Definition transfer_syntax.cpp:21

Examples: /home/runner/work/pacs_system/pacs_system/examples/tutorials/common/test_data_generator.h.

Definition at line 65 of file dicom_dataset.h.

Member Typedef Documentation

◆ const_iterator

using kcenon::pacs::core::dicom_dataset::const_iterator = storage_type::const_iterator

Const iterator type.

Definition at line 74 of file dicom_dataset.h.

◆ iterator

using kcenon::pacs::core::dicom_dataset::iterator = storage_type::iterator

Iterator type.

Definition at line 71 of file dicom_dataset.h.

◆ storage_type

using kcenon::pacs::core::dicom_dataset::storage_type = std::map<dicom_tag, dicom_element>

Storage type for elements (ordered by tag)

Definition at line 68 of file dicom_dataset.h.

Constructor & Destructor Documentation

◆ dicom_dataset() [1/3]

kcenon::pacs::core::dicom_dataset::dicom_dataset ( )

default

Default constructor - creates an empty dataset.

◆ dicom_dataset() [2/3]

kcenon::pacs::core::dicom_dataset::dicom_dataset ( const dicom_dataset & )

default

Copy constructor.

◆ dicom_dataset() [3/3]

kcenon::pacs::core::dicom_dataset::dicom_dataset ( dicom_dataset && )

defaultnoexcept

Move constructor.

◆ ~dicom_dataset()

kcenon::pacs::core::dicom_dataset::~dicom_dataset ( )

default

Default destructor.

Member Function Documentation

◆ begin() [1/2]

auto kcenon::pacs::core::dicom_dataset::begin ( ) const -> const_iterator

nodiscardnoexcept

Get const iterator to the first element.

Returns: Const iterator to the beginning

Definition at line 311 of file dicom_dataset.cpp.

                                                           {
    return elements_.begin();
}

References elements_.

◆ begin() [2/2]

auto kcenon::pacs::core::dicom_dataset::begin ( ) -> iterator

nodiscardnoexcept

Get iterator to the first element.

Returns: Iterator to the beginning

Definition at line 303 of file dicom_dataset.cpp.

                                               {
    return elements_.begin();
}

References elements_.

◆ cbegin()

auto kcenon::pacs::core::dicom_dataset::cbegin ( ) const -> const_iterator

nodiscardnoexcept

Get const iterator to the first element.

Returns: Const iterator to the beginning

Definition at line 319 of file dicom_dataset.cpp.

                                                            {
    return elements_.cbegin();
}

References elements_.

◆ cend()

auto kcenon::pacs::core::dicom_dataset::cend ( ) const -> const_iterator

nodiscardnoexcept

Get const iterator past the last element.

Returns: Const iterator to the end

Definition at line 323 of file dicom_dataset.cpp.

                                                          {
    return elements_.cend();
}

References elements_.

◆ cleanup_orphaned_creators()

auto kcenon::pacs::core::dicom_dataset::cleanup_orphaned_creators ( ) -> size_t

Remove orphaned Private Creator elements that have no data elements.

Returns: Number of orphaned creators removed

Definition at line 234 of file dicom_dataset.cpp.

                                                        {
    size_t removed = 0;
    std::vector<dicom_tag> orphans;
 
    for (const auto& [tag, elem] : elements_) {
        if (!tag.is_private_creator()) {
            continue;
        }
        // Check if any data elements exist in this creator's block
        const auto range = tag.private_data_range();
        if (!range) {
            continue;
        }
        const auto [first, last] = *range;
        auto it = elements_.lower_bound(first);
        if (it == elements_.end() || it->first > last) {
            orphans.push_back(tag);
        }
    }
 
    for (const auto& tag : orphans) {
        elements_.erase(tag);
        ++removed;
    }
 
    return removed;
}

◆ clear()

void kcenon::pacs::core::dicom_dataset::clear ( )

noexcept

Remove all elements from the dataset.

Definition at line 295 of file dicom_dataset.cpp.

                                   {
    elements_.clear();
}

References elements_.

◆ contains()

auto kcenon::pacs::core::dicom_dataset::contains ( dicom_tag tag ) const -> bool

nodiscardnoexcept

Check if the dataset contains an element with the given tag.

Parameters

tag	The DICOM tag to check

Returns: true if an element with this tag exists

Definition at line 18 of file dicom_dataset.cpp.

                                                                 {
    return elements_.contains(tag);
}

Here is the caller graph for this function:

◆ copy_with_tags() [1/2]

auto kcenon::pacs::core::dicom_dataset::copy_with_tags ( std::initializer_list< dicom_tag > tags ) const -> dicom_dataset

nodiscard

Create a copy containing only the specified tags.

Parameters

tags	List of tags to include in the copy

Returns: A new dataset containing only the specified elements

Definition at line 343 of file dicom_dataset.cpp.

                     {
    return copy_with_tags(std::span{tags.begin(), tags.size()});
}

◆ copy_with_tags() [2/2]

auto kcenon::pacs::core::dicom_dataset::copy_with_tags ( std::span< const dicom_tag > tags ) const -> dicom_dataset

nodiscard

Create a copy containing only the specified tags.

Parameters

tags	Span of tags to include in the copy

Returns: A new dataset containing only the specified elements

Definition at line 348 of file dicom_dataset.cpp.

                     {
    dicom_dataset result;
 
    for (const auto& tag : tags) {
        const auto* elem = get(tag);
        if (elem != nullptr) {
            result.insert(*elem);
        }
    }
 
    return result;
}

References insert().

Here is the call graph for this function:

◆ empty()

auto kcenon::pacs::core::dicom_dataset::empty ( ) const -> bool

nodiscardnoexcept

Check if the dataset is empty.

Returns: true if no elements are present

Definition at line 335 of file dicom_dataset.cpp.

                                                 {
    return elements_.empty();
}

References elements_.

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

Here is the caller graph for this function:

◆ end() [1/2]

auto kcenon::pacs::core::dicom_dataset::end ( ) const -> const_iterator

nodiscardnoexcept

Get const iterator past the last element.

Returns: Const iterator to the end

Definition at line 315 of file dicom_dataset.cpp.

                                                         {
    return elements_.end();
}

References elements_.

◆ end() [2/2]

auto kcenon::pacs::core::dicom_dataset::end ( ) -> iterator

nodiscardnoexcept

Get iterator past the last element.

Returns: Iterator to the end

Definition at line 307 of file dicom_dataset.cpp.

                                             {
    return elements_.end();
}

References elements_.

◆ get() [1/2]

auto kcenon::pacs::core::dicom_dataset::get ( dicom_tag tag ) const -> const dicom_element*

nodiscardnoexcept

Get a const pointer to the element with the given tag.

Parameters

tag	The DICOM tag to look up

Returns: Const pointer to the element, or nullptr if not found

Definition at line 30 of file dicom_dataset.cpp.

                                                                            {
    auto it = elements_.find(tag);
    if (it == elements_.end()) {
        return nullptr;
    }
    return &it->second;
}

◆ get() [2/2]

auto kcenon::pacs::core::dicom_dataset::get ( dicom_tag tag ) -> dicom_element*

nodiscardnoexcept

Get a pointer to the element with the given tag.

Parameters

tag	The DICOM tag to look up

Returns: Pointer to the element, or nullptr if not found

Definition at line 22 of file dicom_dataset.cpp.

                                                                {
    auto it = elements_.find(tag);
    if (it == elements_.end()) {
        return nullptr;
    }
    return &it->second;
}

Here is the caller graph for this function:

◆ get_numeric()

template<typename T >
requires std::is_arithmetic_v<T>

auto kcenon::pacs::core::dicom_dataset::get_numeric ( dicom_tag tag ) const -> std::optional<T>

nodiscard

Get the numeric value of an element.

Template Parameters

T	The numeric type to return

Parameters

tag	The DICOM tag to look up

Returns: Optional containing the value, or nullopt if not found/conversion fails

Definition at line 433 of file dicom_dataset.h.

                                                                     {
    const auto* elem = get(tag);
    if (elem == nullptr) {
        return std::nullopt;
    }
 
    auto result = elem->as_numeric<T>();
    if (result.is_ok()) {
        return result.value();
    }
    return std::nullopt;
}

References get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_or_create_sequence()

auto kcenon::pacs::core::dicom_dataset::get_or_create_sequence ( dicom_tag tag ) -> std::vector<dicom_dataset>&

nodiscard

Insert or create a sequence element with the given tag.

Parameters

tag	The DICOM tag for the sequence

Returns: Reference to the sequence items vector (creates empty sequence if not exists)

If an element with the tag already exists and is not a sequence, it will be replaced with an empty sequence.

Definition at line 79 of file dicom_dataset.cpp.

                                 {
    auto* elem = get(tag);
    if (elem != nullptr && elem->is_sequence()) {
        return elem->sequence_items();
    }
    // Create or replace with empty sequence
    insert(dicom_element{tag, encoding::vr_type::SQ});
    return get(tag)->sequence_items();
}

References kcenon::pacs::encoding::SQ.

Referenced by kcenon::pacs::services::storage_commitment_scu::build_action_dataset(), kcenon::pacs::services::storage_commitment_scp::build_event_report_dataset(), kcenon::pacs::services::print_scp::create_film_box(), and kcenon::pacs::services::print_scu::create_film_box().

Here is the caller graph for this function:

◆ get_private_block()

auto kcenon::pacs::core::dicom_dataset::get_private_block	(	std::string_view	creator_id,
		uint16_t	group ) const -> std::vector<const dicom_element*>

nodiscard

Get all private data elements belonging to a specific creator.

Searches the given group for a Private Creator element matching creator_id, then returns all data elements in that creator's block.

Parameters

creator_id	The Private Creator identification string (e.g. "SIEMENS CSA HEADER")
group	The private group number (must be odd)

Returns: Vector of pointers to matching data elements (empty if none found)

Definition at line 111 of file dicom_dataset.cpp.

                                       {
    std::vector<const dicom_element*> result;
 
    // Scan Private Creator elements (gggg,0010)-(gggg,00FF) for a match
    for (uint16_t slot = 0x0010; slot <= 0x00FF; ++slot) {
        const dicom_tag creator_tag{group, slot};
        const auto* creator_elem = get(creator_tag);
        if (creator_elem == nullptr) {
            continue;
        }
        auto str_result = creator_elem->as_string();
        if (str_result.is_err() || str_result.value() != creator_id) {
            continue;
        }
 
        // Found the creator — collect all data elements in its block
        const auto range = creator_tag.private_data_range();
        if (!range) {
            break;
        }
        const auto [first, last] = *range;
        auto it = elements_.lower_bound(first);
        while (it != elements_.end() && it->first <= last) {
            result.push_back(&it->second);
            ++it;
        }
        break;
    }
 
    return result;
}

◆ get_private_creator()

auto kcenon::pacs::core::dicom_dataset::get_private_creator ( dicom_tag private_data_tag ) const -> std::optional<std::string>

nodiscard

Get the Private Creator identification string for a private data element.

Looks up the Private Creator element (gggg,00xx) for a given private data element (gggg,xxyy) and returns its string value.

Parameters

private_data_tag A private data element tag

Returns: The creator identification string, or nullopt if not found

Definition at line 94 of file dicom_dataset.cpp.

                              {
    const auto creator_tag = private_data_tag.private_creator_tag();
    if (!creator_tag) {
        return std::nullopt;
    }
    const auto* elem = get(*creator_tag);
    if (elem == nullptr) {
        return std::nullopt;
    }
    auto result = elem->as_string();
    if (result.is_ok()) {
        return result.value();
    }
    return std::nullopt;
}

Referenced by kcenon::pacs::core::dicom_file::decode_implicit_vr_le().

Here is the caller graph for this function:

◆ get_sequence() [1/2]

auto kcenon::pacs::core::dicom_dataset::get_sequence ( dicom_tag tag ) const -> const std::vector<dicom_dataset>*

nodiscardnoexcept

Get read-only access to sequence items for a given tag.

Parameters

tag	The DICOM tag of the sequence element

Returns: Pointer to the sequence items vector, or nullptr if not found or not a sequence

Example:: // Access Performed Series Sequence (0040,0340)

if (const auto* series = dataset.get_sequence(tags::performed_series_sequence)) {

for (const auto& item : *series) {

auto series_uid = item.get_string(tags::series_instance_uid);

}

}

kcenon::pacs::core::tags::series_instance_uid
constexpr dicom_tag series_instance_uid
Series Instance UID.
Definition dicom_tag_constants.h:272

Definition at line 61 of file dicom_dataset.cpp.

                                       {
    const auto* elem = get(tag);
    if (elem == nullptr || !elem->is_sequence()) {
        return nullptr;
    }
    return &elem->sequence_items();
}

Referenced by kcenon::pacs::services::storage_commitment_scu::parse_event_report_dataset(), and kcenon::pacs::services::storage_commitment_scp::parse_referenced_sop_sequence().

Here is the caller graph for this function:

◆ get_sequence() [2/2]

auto kcenon::pacs::core::dicom_dataset::get_sequence ( dicom_tag tag ) -> std::vector<dicom_dataset>*

nodiscardnoexcept

Get mutable access to sequence items for a given tag.

Parameters

tag	The DICOM tag of the sequence element

Returns: Pointer to the sequence items vector, or nullptr if not found or not a sequence

Definition at line 70 of file dicom_dataset.cpp.

                                 {
    auto* elem = get(tag);
    if (elem == nullptr || !elem->is_sequence()) {
        return nullptr;
    }
    return &elem->sequence_items();
}

◆ get_string()

auto kcenon::pacs::core::dicom_dataset::get_string	(	dicom_tag	tag,
		std::string_view	default_value = "" ) const -> std::string

nodiscard

Get the string value of an element.

Parameters

tag	The DICOM tag to look up
default_value	Value to return if element not found

Returns: The element's string value, or default_value if not found

Definition at line 42 of file dicom_dataset.cpp.

                 {
    const auto* elem = get(tag);
    if (elem == nullptr) {
        return std::string{default_value};
    }
    return elem->as_string().unwrap_or(std::string{default_value});
}

Here is the caller graph for this function:

◆ has_sequence()

auto kcenon::pacs::core::dicom_dataset::has_sequence ( dicom_tag tag ) const -> bool

nodiscardnoexcept

Check if the dataset contains a sequence element with the given tag.

Parameters

tag	The DICOM tag to check

Returns: true if an element with this tag exists and is a sequence (VR = SQ)

Definition at line 56 of file dicom_dataset.cpp.

                                                                     {
    const auto* elem = get(tag);
    return elem != nullptr && elem->is_sequence();
}

◆ insert()

void kcenon::pacs::core::dicom_dataset::insert ( dicom_element element )

Insert or replace an element in the dataset.

Parameters

element The element to insert (copied or moved)

If an element with the same tag already exists, it will be replaced. Use std::move() when passing the element to avoid unnecessary copies.

Definition at line 282 of file dicom_dataset.cpp.

                                                {
    elements_.insert_or_assign(element.tag(), std::move(element));
}

References elements_, and kcenon::pacs::core::dicom_element::tag().

Referenced by copy_with_tags(), kcenon::pacs::encoding::explicit_vr_big_endian_codec::decode(), kcenon::pacs::encoding::explicit_vr_codec::decode(), kcenon::pacs::encoding::implicit_vr_codec::decode(), kcenon::pacs::core::dicom_file::decode_explicit_vr_be(), kcenon::pacs::core::dicom_file::decode_explicit_vr_le(), kcenon::pacs::core::dicom_file::decode_implicit_vr_le(), kcenon::pacs::integration::container_adapter::deserialize_dataset(), kcenon::pacs::core::dicom_file::generate_meta_information(), merge(), merge(), kcenon::pacs::core::dicom_file::parse_meta_information(), kcenon::pacs::network::dimse::dimse_message::set_attribute_identifier_list(), kcenon::pacs::encoding::set_encoded_string(), set_numeric(), and set_string().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ merge() [1/2]

void kcenon::pacs::core::dicom_dataset::merge ( const dicom_dataset & other )

Merge elements from another dataset.

Parameters

other The dataset to merge from

Elements from 'other' will overwrite existing elements with the same tag.

Definition at line 362 of file dicom_dataset.cpp.

                                                    {
    for (const auto& [tag, element] : other) {
        insert(element);
    }
}

References insert().

Here is the call graph for this function:

◆ merge() [2/2]

void kcenon::pacs::core::dicom_dataset::merge ( dicom_dataset && other )

Merge elements from another dataset (move version)

Parameters

other The dataset to merge from (moved)

Definition at line 368 of file dicom_dataset.cpp.

                                               {
    for (auto& [tag, element] : other.elements_) {
        insert(std::move(element));
    }
    other.clear();
}

References insert().

Here is the call graph for this function:

◆ operator=() [1/2]

auto kcenon::pacs::core::dicom_dataset::operator= ( const dicom_dataset & ) -> dicom_dataset &=default

default

Copy assignment.

◆ operator=() [2/2]

auto kcenon::pacs::core::dicom_dataset::operator= ( dicom_dataset && ) -> dicom_dataset &=default

defaultnoexcept

Move assignment.

◆ remove()

auto kcenon::pacs::core::dicom_dataset::remove ( dicom_tag tag ) -> bool

Remove an element from the dataset.

Parameters

tag	The tag of the element to remove

Returns: true if an element was removed, false if not found

Definition at line 291 of file dicom_dataset.cpp.

                                                {
    return elements_.erase(tag) > 0;
}

Referenced by kcenon::pacs::network::dimse::dimse_message::update_command_group_length().

Here is the caller graph for this function:

◆ remove_private_block()

auto kcenon::pacs::core::dicom_dataset::remove_private_block	(	std::string_view	creator_id,
		uint16_t	group ) -> size_t

Remove all private data elements and their creator for a given creator.

Removes both the Private Creator element and all associated data elements in the specified group.

Parameters

creator_id	The Private Creator identification string
group	The private group number (must be odd)

Returns: Number of elements removed (including the creator)

Definition at line 199 of file dicom_dataset.cpp.

                                                                    {
    size_t removed = 0;
 
    for (uint16_t slot = 0x0010; slot <= 0x00FF; ++slot) {
        const dicom_tag creator_tag{group, slot};
        const auto* creator_elem = get(creator_tag);
        if (creator_elem == nullptr) {
            continue;
        }
        auto str_result = creator_elem->as_string();
        if (str_result.is_err() || str_result.value() != creator_id) {
            continue;
        }
 
        // Found the creator — remove all data elements in its block
        const auto range = creator_tag.private_data_range();
        if (range) {
            const auto [first, last] = *range;
            auto it = elements_.lower_bound(first);
            while (it != elements_.end() && it->first <= last) {
                it = elements_.erase(it);
                ++removed;
            }
        }
 
        // Remove the creator element itself
        elements_.erase(creator_tag);
        ++removed;
        break;
    }
 
    return removed;
}

◆ set_numeric()

template<typename T >
requires std::is_arithmetic_v<T>

void kcenon::pacs::core::dicom_dataset::set_numeric	(	dicom_tag	tag,
		encoding::vr_type	vr,
		T	value )

Set a numeric value for the given tag.

Template Parameters

T	The numeric type

Parameters

tag	The DICOM tag
vr	The value representation
value	The numeric value

Definition at line 448 of file dicom_dataset.h.

                                                                          {
    insert(dicom_element::from_numeric<T>(tag, vr, value));
}

References kcenon::pacs::core::dicom_element::from_numeric(), insert(), and vr.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_private_element()

auto kcenon::pacs::core::dicom_dataset::set_private_element	(	std::string_view	creator_id,
		uint16_t	group,
		uint8_t	element_offset,
		encoding::vr_type	vr,
		std::string_view	value ) -> std::optional<dicom_tag>

Insert a private data element with automatic creator management.

Automatically ensures the corresponding Private Creator element exists. If the creator already owns a block in the given group, reuses that block. Otherwise, allocates the next available slot.

Per DICOM PS3.5 §7.8.1, Private Creator elements are placed at (gggg,00xx) and data elements at (gggg,xxyy).

Parameters

creator_id	Private Creator identification (e.g. "SIEMENS CSA HEADER")
group	Odd group number (e.g. 0x0009)
element_offset	Offset within the block (0x00-0xFF)
vr	Value Representation for the data element
value	The element value

Returns: The actual tag assigned, or nullopt if allocation failed

Definition at line 145 of file dicom_dataset.cpp.

                              {
    // Group must be odd and > 0x0008 for private tags
    if ((group & 1) == 0 || group <= 0x0008) {
        return std::nullopt;
    }
 
    // Find existing block for this creator, or allocate a new slot
    uint16_t block_number = 0;
    bool found = false;
 
    for (uint16_t slot = 0x0010; slot <= 0x00FF; ++slot) {
        const dicom_tag creator_tag{group, slot};
        const auto* creator_elem = get(creator_tag);
        if (creator_elem == nullptr) {
            // Empty slot — allocate if we haven't found a match yet
            if (!found) {
                block_number = slot;
                found = true;
            }
            continue;
        }
        auto str_result = creator_elem->as_string();
        if (str_result.is_ok() && str_result.value() == creator_id) {
            // Creator already owns this slot
            block_number = slot;
            found = true;
            break;
        }
    }
 
    if (!found) {
        return std::nullopt;  // No available slots
    }
 
    // Ensure the Private Creator element exists
    const dicom_tag creator_tag{group, block_number};
    if (get(creator_tag) == nullptr) {
        set_string(creator_tag, encoding::vr_type::LO, creator_id);
    }
 
    // Place the data element at (group, block_number << 8 | element_offset)
    const auto data_element_num = static_cast<uint16_t>(
        (block_number << 8) | element_offset);
    const dicom_tag data_tag{group, data_element_num};
    set_string(data_tag, vr, value);
 
    return data_tag;
}

References kcenon::pacs::encoding::LO, and vr.

◆ set_string()

void kcenon::pacs::core::dicom_dataset::set_string	(	dicom_tag	tag,
		encoding::vr_type	vr,
		std::string_view	value )

Set a string value for the given tag.

Parameters

tag	The DICOM tag
vr	The value representation
value	The string value

Creates a new element or updates an existing one.

Definition at line 286 of file dicom_dataset.cpp.

                                                     {
    insert(dicom_element::from_string(tag, vr, value));
}

References kcenon::pacs::core::dicom_element::from_string(), insert(), and vr.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ size()

auto kcenon::pacs::core::dicom_dataset::size ( ) const -> size_t

nodiscardnoexcept

Get the number of elements in the dataset.

Returns: The element count

Definition at line 331 of file dicom_dataset.cpp.

                                                  {
    return elements_.size();
}

References elements_.

Referenced by main(), and kcenon::pacs::services::storage_scu::store_impl().

Here is the caller graph for this function:

◆ validate_private_tags()

auto kcenon::pacs::core::dicom_dataset::validate_private_tags ( ) const -> std::vector<dicom_tag>

nodiscard

Validate private tag relationships in this dataset.

Checks that every private data element has a corresponding Private Creator element and returns tags that are missing their creator.

Returns: Vector of private data element tags missing their Private Creator

Definition at line 262 of file dicom_dataset.cpp.

                                                                        {
    std::vector<dicom_tag> missing_creators;
 
    for (const auto& [tag, elem] : elements_) {
        if (!tag.is_private_data()) {
            continue;
        }
        const auto creator_tag = tag.private_creator_tag();
        if (!creator_tag || !contains(*creator_tag)) {
            missing_creators.push_back(tag);
        }
    }
 
    return missing_creators;
}

References contains(), and elements_.

Here is the call graph for this function:

Member Data Documentation

◆ elements_

storage_type kcenon::pacs::core::dicom_dataset::elements_

private

Definition at line 424 of file dicom_dataset.h.

Referenced by begin(), begin(), cbegin(), cend(), clear(), empty(), end(), end(), insert(), size(), and validate_private_tags().

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

include/kcenon/pacs/core/dicom_dataset.h
src/core/dicom_dataset.cpp

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ const_iterator

◆ iterator

◆ storage_type

Constructor & Destructor Documentation

◆ dicom_dataset() [1/3]

◆ dicom_dataset() [2/3]

◆ dicom_dataset() [3/3]

◆ ~dicom_dataset()

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ cleanup_orphaned_creators()

◆ clear()

◆ contains()

◆ copy_with_tags() [1/2]

◆ copy_with_tags() [2/2]

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ get() [1/2]

◆ get() [2/2]

◆ get_numeric()

◆ get_or_create_sequence()

◆ get_private_block()

◆ get_private_creator()

◆ get_sequence() [1/2]

◆ get_sequence() [2/2]

◆ get_string()

◆ has_sequence()

◆ insert()

◆ merge() [1/2]

◆ merge() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ remove()

◆ remove_private_block()

◆ set_numeric()

◆ set_private_element()

◆ set_string()

◆ size()

◆ validate_private_tags()

Member Data Documentation

◆ elements_