dicom_tag.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <compare>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
 
namespace kcenon::pacs::core {
 
class dicom_tag {
public:
    constexpr dicom_tag() noexcept : combined_{0} {}
 
    constexpr dicom_tag(uint16_t group, uint16_t element) noexcept
        : combined_{static_cast<uint32_t>(group) << 16 | element} {}
 
    explicit constexpr dicom_tag(uint32_t combined) noexcept
        : combined_{combined} {}
 
    [[nodiscard]] static auto from_string(std::string_view str)
        -> std::optional<dicom_tag>;
 
    [[nodiscard]] constexpr auto group() const noexcept -> uint16_t {
        return static_cast<uint16_t>(combined_ >> 16);
    }
 
    [[nodiscard]] constexpr auto element() const noexcept -> uint16_t {
        return static_cast<uint16_t>(combined_ & 0xFFFF);
    }
 
    [[nodiscard]] constexpr auto combined() const noexcept -> uint32_t {
        return combined_;
    }
 
    [[nodiscard]] constexpr auto is_private() const noexcept -> bool {
        const auto grp = group();
        return (grp & 1) != 0 && grp > 0x0008;
    }
 
    [[nodiscard]] constexpr auto is_group_length() const noexcept -> bool {
        return element() == 0x0000;
    }
 
    [[nodiscard]] constexpr auto is_private_creator() const noexcept -> bool {
        if (!is_private()) {
            return false;
        }
        const auto elem = element();
        return elem >= 0x0010 && elem <= 0x00FF;
    }
 
    [[nodiscard]] constexpr auto is_private_data() const noexcept -> bool {
        return is_private() && element() > 0x00FF;
    }
 
    [[nodiscard]] constexpr auto private_block_number() const noexcept
        -> std::optional<uint8_t> {
        if (!is_private_data()) {
            return std::nullopt;
        }
        return static_cast<uint8_t>(element() >> 8);
    }
 
    [[nodiscard]] constexpr auto private_creator_tag() const noexcept
        -> std::optional<dicom_tag> {
        const auto block = private_block_number();
        if (!block) {
            return std::nullopt;
        }
        return dicom_tag{group(), *block};
    }
 
    [[nodiscard]] constexpr auto private_data_range() const noexcept
        -> std::optional<std::pair<dicom_tag, dicom_tag>> {
        if (!is_private_creator()) {
            return std::nullopt;
        }
        const auto block = static_cast<uint16_t>(element() << 8);
        return std::pair{
            dicom_tag{group(), block},
            dicom_tag{group(), static_cast<uint16_t>(block | 0x00FF)}
        };
    }
 
    [[nodiscard]] auto to_string() const -> std::string;
 
    [[nodiscard]] constexpr auto operator<=>(const dicom_tag& other) const noexcept
        -> std::strong_ordering = default;
 
    [[nodiscard]] constexpr auto operator==(const dicom_tag& other) const noexcept
        -> bool = default;
 
private:
    uint32_t combined_;
};
 
}  // namespace kcenon::pacs::core
 
 
// Hash specialization for use in unordered containers
template <>
struct std::hash<kcenon::pacs::core::dicom_tag> {
    [[nodiscard]] auto operator()(const kcenon::pacs::core::dicom_tag& tag) const noexcept
        -> size_t {
        return std::hash<uint32_t>{}(tag.combined());
    }
};