kcenon::pacs::core::dicom_dictionary Class Reference

DICOM Data Dictionary singleton class. More...

#include <dicom_dictionary.h>

Collaboration diagram for kcenon::pacs::core::dicom_dictionary:

Public Member Functions
	dicom_dictionary (const dicom_dictionary &)=delete
	dicom_dictionary (dicom_dictionary &&)=delete
auto	operator= (const dicom_dictionary &) -> dicom_dictionary &=delete
auto	operator= (dicom_dictionary &&) -> dicom_dictionary &=delete
auto	find (dicom_tag tag) const -> std::optional< tag_info >
	Find tag metadata by DICOM tag.
auto	find_by_keyword (std::string_view keyword) const -> std::optional< tag_info >
	Find tag metadata by keyword.
auto	contains (dicom_tag tag) const -> bool
	Check if a tag exists in the dictionary.
auto	contains_keyword (std::string_view keyword) const -> bool
	Check if a keyword exists in the dictionary.
auto	validate_vm (dicom_tag tag, uint32_t count) const -> bool
	Validate that a value count is valid for a tag's VM.
auto	get_vr (dicom_tag tag) const -> uint16_t
	Get the VR type for a tag.
auto	register_private_tag (const tag_info &info) -> bool
	Register a private tag at runtime.
auto	size () const -> size_t
	Get the total number of tags in the dictionary.
auto	standard_tag_count () const -> size_t
	Get the number of standard (non-private) tags.
auto	private_tag_count () const -> size_t
	Get the number of registered private tags.
auto	get_tags_in_group (uint16_t group) const -> std::vector< tag_info >
	Get all tags in a specific group.

Static Public Member Functions
static auto	instance () -> dicom_dictionary &
	Get the singleton instance.

Private Member Functions
	dicom_dictionary ()
	Private constructor - initializes with standard tags.
void	initialize_standard_tags ()
	Initialize the dictionary with standard PS3.6 tags.

Private Attributes
std::unordered_map< dicom_tag, tag_info >	tag_map_
	Hash map for O(1) lookup by tag.
std::unordered_map< std::string_view, dicom_tag >	keyword_map_
	Hash map for O(1) lookup by keyword.
size_t	standard_count_ {0}
	Count of standard tags (vs private)
std::shared_mutex	mutex_
	Mutex for thread-safe private tag registration.

Detailed Description

DICOM Data Dictionary singleton class.

Provides O(1) lookup for DICOM tag metadata including VR, VM, keyword, and name. The dictionary is initialized with all standard tags from PS3.6 and supports runtime registration of private tags.

Thread Safety:

• Read operations (lookup) are thread-safe and can be concurrent
• Write operations (register_private_tag) are serialized

Example:

auto& dict = dicom_dictionary::instance();
 
// Lookup by tag
if (auto info = dict.find(dicom_tag{0x0010, 0x0010})) {
    std::cout << info->name;  // "Patient's Name"
}
 
// Lookup by keyword
if (auto info = dict.find_by_keyword("PatientName")) {
    std::cout << info->tag.to_string();  // "(0010,0010)"
}
 
// Validate VM
if (dict.validate_vm(dicom_tag{0x0008, 0x0060}, 1)) {
    // Value count is valid for Modality tag
}

Definition at line 65 of file dicom_dictionary.h.

Constructor & Destructor Documentation

dicom_dictionary() [1/3]

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

delete

dicom_dictionary() [2/3]

kcenon::pacs::core::dicom_dictionary::dicom_dictionary ( dicom_dictionary && )

delete

dicom_dictionary() [3/3]

kcenon::pacs::core::dicom_dictionary::dicom_dictionary ( )

private

Private constructor - initializes with standard tags.

Definition at line 25 of file dicom_dictionary.cpp.

                                   {
    initialize_standard_tags();
}

References initialize_standard_tags().

Here is the call graph for this function:

Member Function Documentation

contains()

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

nodiscard

Check if a tag exists in the dictionary.

Parameters

tag	The DICOM tag to check

Returns

true if the tag is in the dictionary

Definition at line 69 of file dicom_dictionary.cpp.

                                                           {
    std::shared_lock lock(mutex_);
    return tag_map_.contains(tag);
}

contains_keyword()

auto kcenon::pacs::core::dicom_dictionary::contains_keyword ( std::string_view keyword ) const -> bool

nodiscard

Check if a keyword exists in the dictionary.

Parameters

keyword

The keyword to check

Returns

true if the keyword is in the dictionary

Definition at line 74 of file dicom_dictionary.cpp.

                                                                            {
    std::shared_lock lock(mutex_);
    return keyword_map_.contains(keyword);
}

find()

auto kcenon::pacs::core::dicom_dictionary::find ( dicom_tag tag ) const -> std::optional<tag_info>

nodiscard

Find tag metadata by DICOM tag.

Parameters

tag	The DICOM tag to look up

Returns

Optional containing tag_info if found, nullopt otherwise

O(1) average time complexity using hash table lookup. Thread-safe for concurrent reads.

Definition at line 45 of file dicom_dictionary.cpp.

                                                                        {
    std::shared_lock lock(mutex_);
 
    const auto it = tag_map_.find(tag);
    if (it != tag_map_.end()) {
        return it->second;
    }
    return std::nullopt;
}

find_by_keyword()

auto kcenon::pacs::core::dicom_dictionary::find_by_keyword ( std::string_view keyword ) const -> std::optional<tag_info>

nodiscard

Find tag metadata by keyword.

Parameters

keyword

The tag keyword (e.g., "PatientName")

Returns

Optional containing tag_info if found, nullopt otherwise

O(1) average time complexity using hash table lookup. Thread-safe for concurrent reads.

Definition at line 55 of file dicom_dictionary.cpp.

                             {
    std::shared_lock lock(mutex_);
 
    const auto it = keyword_map_.find(keyword);
    if (it != keyword_map_.end()) {
        const auto tag_it = tag_map_.find(it->second);
        if (tag_it != tag_map_.end()) {
            return tag_it->second;
        }
    }
    return std::nullopt;
}

get_tags_in_group()

auto kcenon::pacs::core::dicom_dictionary::get_tags_in_group ( uint16_t group ) const -> std::vector<tag_info>

nodiscard

Get all tags in a specific group.

Parameters

group

The group number to filter by

Returns

Vector of tag_info for all tags in the group

Definition at line 130 of file dicom_dictionary.cpp.

                           {
    std::shared_lock lock(mutex_);
 
    std::vector<tag_info> result;
    for (const auto& [tag, info] : tag_map_) {
        if (tag.group() == group) {
            result.push_back(info);
        }
    }
 
    std::sort(result.begin(), result.end(),
              [](const auto& a, const auto& b) {
                  return a.tag < b.tag;
              });
 
    return result;
}

get_vr()

auto kcenon::pacs::core::dicom_dictionary::get_vr ( dicom_tag tag ) const -> uint16_t

nodiscard

Get the VR type for a tag.

Parameters

tag	The DICOM tag

Returns

The VR type as uint16_t, or 0 if tag not found

Definition at line 87 of file dicom_dictionary.cpp.

                                                             {
    const auto info = find(tag);
    if (!info) {
        return 0;
    }
    return info->vr;
}

initialize_standard_tags()

void kcenon::pacs::core::dicom_dictionary::initialize_standard_tags ( )

private

Initialize the dictionary with standard PS3.6 tags.

Definition at line 29 of file dicom_dictionary.cpp.

                                                {
    const auto tags = get_standard_tags();
 
    tag_map_.reserve(tags.size());
    keyword_map_.reserve(tags.size());
 
    for (const auto& info : tags) {
        tag_map_.emplace(info.tag, info);
        if (!info.keyword.empty()) {
            keyword_map_.emplace(info.keyword, info.tag);
        }
    }
 
    standard_count_ = tags.size();
}

References kcenon::pacs::core::get_standard_tags(), keyword_map_, standard_count_, and tag_map_.

Referenced by dicom_dictionary().

Here is the call graph for this function:

Here is the caller graph for this function:

instance()

auto kcenon::pacs::core::dicom_dictionary::instance ( ) -> dicom_dictionary&

staticnodiscard

Get the singleton instance.

Returns

Reference to the global dicom_dictionary instance

Thread-safe initialization using C++11 static initialization guarantee.

Definition at line 20 of file dicom_dictionary.cpp.

                                                     {
    static dicom_dictionary instance;
    return instance;
}

Referenced by kcenon::pacs::encoding::implicit_vr_codec::decode_element(), and kcenon::pacs::core::dicom_file::decode_implicit_vr_le().

Here is the caller graph for this function:

operator=() [1/2]

auto kcenon::pacs::core::dicom_dictionary::operator= ( const dicom_dictionary & ) -> dicom_dictionary &=delete

delete

operator=() [2/2]

auto kcenon::pacs::core::dicom_dictionary::operator= ( dicom_dictionary && ) -> dicom_dictionary &=delete

delete

private_tag_count()

auto kcenon::pacs::core::dicom_dictionary::private_tag_count ( ) const -> size_t

nodiscard

Get the number of registered private tags.

Returns

The count of runtime-registered private tags

Definition at line 125 of file dicom_dictionary.cpp.

                                                         {
    std::shared_lock lock(mutex_);
    return tag_map_.size() - standard_count_;
}

References mutex_, standard_count_, and tag_map_.

register_private_tag()

auto kcenon::pacs::core::dicom_dictionary::register_private_tag

(

const tag_info &

info

)

-> bool

Register a private tag at runtime.

Parameters

info	The tag_info for the private tag

Returns

true if registration succeeded, false if tag already exists

Only private tags (odd group numbers > 0x0008) can be registered. Thread-safe, serializes write operations.

Definition at line 95 of file dicom_dictionary.cpp.

                                                                        {
    // Only allow private tags
    if (!info.tag.is_private()) {
        return false;
    }
 
    std::unique_lock lock(mutex_);
 
    // Check if already exists
    if (tag_map_.contains(info.tag)) {
        return false;
    }
 
    tag_map_.emplace(info.tag, info);
    if (!info.keyword.empty()) {
        keyword_map_.emplace(info.keyword, info.tag);
    }
 
    return true;
}

size()

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

nodiscard

Get the total number of tags in the dictionary.

Returns

The count of registered tags (standard + private)

Definition at line 116 of file dicom_dictionary.cpp.

                                            {
    std::shared_lock lock(mutex_);
    return tag_map_.size();
}

References mutex_, and tag_map_.

standard_tag_count()

auto kcenon::pacs::core::dicom_dictionary::standard_tag_count ( ) const -> size_t

nodiscard

Get the number of standard (non-private) tags.

Returns

The count of standard PS3.6 tags

Definition at line 121 of file dicom_dictionary.cpp.

                                                          {
    return standard_count_;
}

References standard_count_.

validate_vm()

auto kcenon::pacs::core::dicom_dictionary::validate_vm ( dicom_tag tag, uint32_t count ) const -> bool

nodiscard

Validate that a value count is valid for a tag's VM.

Parameters

tag	The DICOM tag to validate against
count	The number of values to validate

Returns

true if count satisfies the tag's VM, false if tag not found or invalid

Definition at line 79 of file dicom_dictionary.cpp.

                                                                              {
    const auto info = find(tag);
    if (!info) {
        return false;
    }
    return info->vm.is_valid(count);
}

Member Data Documentation

keyword_map_

std::unordered_map<std::string_view, dicom_tag> kcenon::pacs::core::dicom_dictionary::keyword_map_

private

Hash map for O(1) lookup by keyword.

Definition at line 182 of file dicom_dictionary.h.

Referenced by initialize_standard_tags().

mutex_

std::shared_mutex kcenon::pacs::core::dicom_dictionary::mutex_

mutableprivate

Mutex for thread-safe private tag registration.

Definition at line 188 of file dicom_dictionary.h.

Referenced by private_tag_count(), and size().

standard_count_

size_t kcenon::pacs::core::dicom_dictionary::standard_count_ {0}

private

Count of standard tags (vs private)

Definition at line 185 of file dicom_dictionary.h.

{0};

Referenced by initialize_standard_tags(), private_tag_count(), and standard_tag_count().

tag_map_

std::unordered_map<dicom_tag, tag_info> kcenon::pacs::core::dicom_dictionary::tag_map_

private

Hash map for O(1) lookup by tag.

Definition at line 179 of file dicom_dictionary.h.

Referenced by initialize_standard_tags(), private_tag_count(), and size().

---

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

• include/kcenon/pacs/core/dicom_dictionary.h
• src/core/dicom_dictionary.cpp