#include <s3_storage.h>

Inheritance diagram for kcenon::pacs::storage::s3_storage:

Collaboration diagram for kcenon::pacs::storage::s3_storage:

Classes
class	s3_client_interface
	Abstract interface for S3 client operations. More...

Public Member Functions
	s3_storage (const cloud_storage_config &config)
	Construct S3 storage with configuration.

	~s3_storage () override
	Destructor.

	s3_storage (const s3_storage &)=delete
	Non-copyable (contains mutex)

s3_storage &	operator= (const s3_storage &)=delete

	s3_storage (s3_storage &&)=delete
	Non-movable (contains mutex)

s3_storage &	operator= (s3_storage &&)=delete

auto	store (const core::dicom_dataset &dataset) -> VoidResult override
	Store a DICOM dataset to S3.

auto	retrieve (std::string_view sop_instance_uid) -> Result< core::dicom_dataset > override
	Retrieve a DICOM dataset by SOP Instance UID.

auto	remove (std::string_view sop_instance_uid) -> VoidResult override
	Remove a DICOM object from S3.

auto	exists (std::string_view sop_instance_uid) const -> bool override
	Check if a DICOM instance exists in S3.

auto	find (const core::dicom_dataset &query) -> Result< std::vector< core::dicom_dataset > > override
	Find DICOM datasets matching query criteria.

auto	get_statistics () const -> storage_statistics override
	Get storage statistics.

auto	verify_integrity () -> VoidResult override
	Verify storage integrity.

auto	store_with_progress (const core::dicom_dataset &dataset, progress_callback callback) -> VoidResult
	Store with progress tracking.

auto	retrieve_with_progress (std::string_view sop_instance_uid, progress_callback callback) -> Result< core::dicom_dataset >
	Retrieve with progress tracking.

auto	get_object_key (std::string_view sop_instance_uid) const -> std::string
	Get the S3 object key for a SOP Instance UID.

auto	bucket_name () const -> const std::string &
	Get the bucket name.

auto	rebuild_index () -> VoidResult
	Rebuild the local index from S3.

auto	is_connected () const -> bool
	Check S3 connectivity.

Public Member Functions inherited from kcenon::pacs::storage::storage_interface
virtual	~storage_interface ()=default
	Virtual destructor for proper polymorphic destruction.

virtual auto	store_batch (const std::vector< core::dicom_dataset > &datasets) -> VoidResult
	Store multiple DICOM datasets in a single operation.

virtual auto	retrieve_batch (const std::vector< std::string > &sop_instance_uids) -> Result< std::vector< core::dicom_dataset > >
	Retrieve multiple DICOM datasets by their SOP Instance UIDs.

Private Member Functions
auto	build_object_key (std::string_view study_uid, std::string_view series_uid, std::string_view sop_uid) const -> std::string
	Build S3 object key for a dataset.

auto	upload_multipart (const std::string &key, const std::vector< std::uint8_t > &data, progress_callback callback) -> VoidResult
	Execute multipart upload for large files.

Static Private Member Functions
static auto	sanitize_uid (std::string_view uid) -> std::string
	Sanitize UID for use in S3 object key.

static auto	matches_query (const core::dicom_dataset &dataset, const core::dicom_dataset &query) -> bool
	Check if dataset matches query criteria.

Private Attributes
cloud_storage_config	config_
	Storage configuration.

std::unique_ptr< s3_client_interface >	client_
	S3 client (mock for testing, AWS SDK for production)

std::unordered_map< std::string, s3_object_info >	index_
	Mapping from SOP Instance UID to S3 object info.

std::shared_mutex	mutex_
	Mutex for thread-safe access.

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::storage::storage_interface
	storage_interface ()=default
	Protected default constructor for derived classes.

	storage_interface (const storage_interface &)=delete
	Non-copyable.

storage_interface &	operator= (const storage_interface &)=delete

	storage_interface (storage_interface &&)=default
	Movable.

storage_interface &	operator= (storage_interface &&)=default

Detailed Description

Definition at line 163 of file s3_storage.h.

Constructor & Destructor Documentation

◆ s3_storage() [1/3]

kcenon::pacs::storage::s3_storage::s3_storage ( const cloud_storage_config & config )

explicit

Construct S3 storage with configuration.

Parameters

config Cloud storage configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 505 of file s3_storage.cpp.

    : config_(config),
#if defined(PACS_WITH_AWS_SDK) && !defined(PACS_USE_MOCK_S3)
      client_(std::make_unique<aws_s3_client>(config))
#else
      client_(std::make_unique<mock_s3_client>(config))
#endif
{
}

◆ ~s3_storage()

kcenon::pacs::storage::s3_storage::~s3_storage ( )

overridedefault

Destructor.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

◆ s3_storage() [2/3]

kcenon::pacs::storage::s3_storage::s3_storage ( const s3_storage & )

delete

Non-copyable (contains mutex)

◆ s3_storage() [3/3]

kcenon::pacs::storage::s3_storage::s3_storage ( s3_storage && )

delete

Non-movable (contains mutex)

Member Function Documentation

◆ bucket_name()

auto kcenon::pacs::storage::s3_storage::bucket_name ( ) const -> const std::string &

nodiscard

Get the bucket name.

Returns: The configured bucket name

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 768 of file s3_storage.cpp.

                                                        {
  return config_.bucket_name;
}

References kcenon::pacs::storage::cloud_storage_config::bucket_name, and config_.

◆ build_object_key()

auto kcenon::pacs::storage::s3_storage::build_object_key	(	std::string_view	study_uid,
		std::string_view	series_uid,
		std::string_view	sop_uid ) const -> std::string

nodiscardprivate

Build S3 object key for a dataset.

Parameters

study_uid	Study Instance UID
series_uid	Series Instance UID
sop_uid	SOP Instance UID

Returns: The constructed object key

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 818 of file s3_storage.cpp.

                 {
  std::ostringstream oss;
  oss << sanitize_uid(study_uid) << "/" << sanitize_uid(series_uid) << "/"
      << sanitize_uid(sop_uid) << ".dcm";
  return oss.str();
}

◆ exists()

auto kcenon::pacs::storage::s3_storage::exists ( std::string_view sop_instance_uid ) const -> bool

nodiscardoverridevirtual

Check if a DICOM instance exists in S3.

Uses S3 HeadObject to check existence without downloading.

Parameters

sop_instance_uid The unique identifier to check

Returns: true if the object exists, false otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 659 of file s3_storage.cpp.

                                                                     {
  std::shared_lock lock(mutex_);
  return index_.contains(std::string{sop_instance_uid});
}

◆ find()

auto kcenon::pacs::storage::s3_storage::find ( const core::dicom_dataset & query ) -> Result<std::vector<core::dicom_dataset>>

nodiscardoverridevirtual

Find DICOM datasets matching query criteria.

This operation requires scanning the local index. For large buckets, consider using the index_database instead.

Parameters

query The query dataset containing search criteria

Returns: Result containing matching datasets or error information

Note: This operation can be slow for large storage

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 664 of file s3_storage.cpp.

                                            {
  std::vector<core::dicom_dataset> results;
 
  std::vector<std::string> keys_to_retrieve;
  {
    std::shared_lock lock(mutex_);
    keys_to_retrieve.reserve(index_.size());
    for (const auto &[uid, info] : index_) {
      keys_to_retrieve.push_back(info.key);
    }
  }
 
  for (const auto &key : keys_to_retrieve) {
    auto download_result = client_->get_object(key);
    if (download_result.is_err()) {
      continue; // Skip objects that can't be downloaded
    }
 
    auto parse_result = core::dicom_file::from_bytes(download_result.value());
    if (parse_result.is_err()) {
      continue; // Skip invalid DICOM files
    }
 
    const auto &dataset = parse_result.value().dataset();
    if (matches_query(dataset, query)) {
      results.push_back(dataset);
    }
  }
 
  return results;
}

References kcenon::pacs::core::dicom_file::from_bytes(), and uid.

Here is the call graph for this function:

◆ get_object_key()

auto kcenon::pacs::storage::s3_storage::get_object_key ( std::string_view sop_instance_uid ) const -> std::string

nodiscard

Get the S3 object key for a SOP Instance UID.

Parameters

sop_instance_uid The SOP Instance UID

Returns: The S3 object key (may be empty if not found)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 758 of file s3_storage.cpp.

                 {
  std::shared_lock lock(mutex_);
  auto it = index_.find(std::string{sop_instance_uid});
  if (it != index_.end()) {
    return it->second.key;
  }
  return {};
}

◆ get_statistics()

auto kcenon::pacs::storage::s3_storage::get_statistics ( ) const -> storage_statistics

nodiscardoverridevirtual

Get storage statistics.

Returns: Storage statistics structure

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 697 of file s3_storage.cpp.

                                                            {
  storage_statistics stats;
 
  std::set<std::string> studies;
  std::set<std::string> series;
  std::set<std::string> patients;
 
  {
    std::shared_lock lock(mutex_);
    stats.total_instances = index_.size();
 
    for (const auto &[uid, info] : index_) {
      stats.total_bytes += info.size_bytes;
 
      if (!info.study_instance_uid.empty()) {
        studies.insert(info.study_instance_uid);
      }
      if (!info.series_instance_uid.empty()) {
        series.insert(info.series_instance_uid);
      }
    }
  }
 
  stats.studies_count = studies.size();
  stats.series_count = series.size();
  // Note: patient_count requires downloading datasets to extract PatientID
 
  return stats;
}

References index_, mutex_, and uid.

◆ is_connected()

auto kcenon::pacs::storage::s3_storage::is_connected ( ) const -> bool

nodiscard

Check S3 connectivity.

Returns: true if S3 is reachable, false otherwise

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 810 of file s3_storage.cpp.

                                            {
  return client_ && client_->is_connected();
}

References client_.

◆ matches_query()

auto kcenon::pacs::storage::s3_storage::matches_query	(	const core::dicom_dataset &	dataset,
		const core::dicom_dataset &	query ) -> bool

staticnodiscardprivate

Check if dataset matches query criteria.

Parameters

dataset	The dataset to check
query	The query criteria

Returns: true if dataset matches query

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 851 of file s3_storage.cpp.

                                                                       {
  // If query is empty, match all
  if (query.empty()) {
    return true;
  }
 
  // Check each query element
  for (const auto &[tag, element] : query) {
    auto query_value = element.as_string().unwrap_or("");
    if (query_value.empty()) {
      continue; // Empty value acts as wildcard
    }
 
    auto dataset_value = dataset.get_string(tag);
 
    // Support basic wildcard matching (* and ?)
    if (query_value.find('*') != std::string::npos ||
        query_value.find('?') != std::string::npos) {
      // Simple pattern matching
      if (query_value.front() == '*' && query_value.back() == '*') {
        // Contains
        auto inner = query_value.substr(1, query_value.length() - 2);
        if (dataset_value.find(inner) == std::string::npos) {
          return false;
        }
      } else if (query_value.front() == '*') {
        // Ends with
        auto suffix = query_value.substr(1);
        if (dataset_value.length() < suffix.length() ||
            dataset_value.substr(dataset_value.length() - suffix.length()) !=
                suffix) {
          return false;
        }
      } else if (query_value.back() == '*') {
        // Starts with
        auto prefix = query_value.substr(0, query_value.length() - 1);
        if (dataset_value.substr(0, prefix.length()) != prefix) {
          return false;
        }
      }
    } else {
      // Exact match
      if (dataset_value != query_value) {
        return false;
      }
    }
  }
 
  return true;
}

◆ operator=() [1/2]

s3_storage & kcenon::pacs::storage::s3_storage::operator= ( const s3_storage & )

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

◆ operator=() [2/2]

s3_storage & kcenon::pacs::storage::s3_storage::operator= ( s3_storage && )

delete

◆ rebuild_index()

auto kcenon::pacs::storage::s3_storage::rebuild_index ( ) -> VoidResult

nodiscard

Rebuild the local index from S3.

Lists all objects in the bucket and rebuilds the SOP UID mapping.

Returns: VoidResult Success or error information

Note: This operation can be slow for buckets with many objects

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 772 of file s3_storage.cpp.

                                             {
  std::unique_lock lock(mutex_);
  index_.clear();
 
  // List all objects from S3
  auto keys = client_->list_objects();
 
  for (const auto &key : keys) {
    // Download and parse each object to rebuild index
    auto download_result = client_->get_object(key);
    if (download_result.is_err()) {
      continue;
    }
 
    auto parse_result = core::dicom_file::from_bytes(download_result.value());
    if (parse_result.is_err()) {
      continue;
    }
 
    const auto &dataset = parse_result.value().dataset();
    auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
    auto study_uid = dataset.get_string(core::tags::study_instance_uid);
    auto series_uid = dataset.get_string(core::tags::series_instance_uid);
 
    if (!sop_uid.empty()) {
      s3_object_info info;
      info.key = key;
      info.sop_instance_uid = sop_uid;
      info.study_instance_uid = study_uid;
      info.series_instance_uid = series_uid;
      info.size_bytes = client_->get_object_size(key);
      index_[sop_uid] = std::move(info);
    }
  }
 
  return ok();
}

References kcenon::pacs::core::dicom_file::from_bytes(), kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Here is the call graph for this function:

◆ remove()

auto kcenon::pacs::storage::s3_storage::remove ( std::string_view sop_instance_uid ) -> VoidResult

nodiscardoverridevirtual

Remove a DICOM object from S3.

Parameters

sop_instance_uid The unique identifier for the instance to remove

Returns: VoidResult Success or error information

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 638 of file s3_storage.cpp.

                                                                     {
  std::string object_key;
 
  {
    std::unique_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it == index_.end()) {
      // Not found is not an error for remove
      return ok();
    }
    object_key = it->second.key;
    index_.erase(it);
  }
 
  // Delete from S3
  auto delete_result = client_->delete_object(object_key);
  // Ignore delete errors - object might have been deleted externally
 
  return ok();
}

◆ retrieve()

auto kcenon::pacs::storage::s3_storage::retrieve ( std::string_view sop_instance_uid ) -> Result<core::dicom_dataset>

nodiscardoverridevirtual

Retrieve a DICOM dataset by SOP Instance UID.

Downloads the object from S3 and deserializes to dicom_dataset.

Parameters

sop_instance_uid The unique identifier for the instance

Returns: Result containing the dataset or error information

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 591 of file s3_storage.cpp.

                                 {
  return retrieve_with_progress(sop_instance_uid, nullptr);
}

◆ retrieve_with_progress()

auto kcenon::pacs::storage::s3_storage::retrieve_with_progress	(	std::string_view	sop_instance_uid,
		progress_callback	callback ) -> Result<core::dicom_dataset>

nodiscard

Retrieve with progress tracking.

Parameters

sop_instance_uid	The SOP Instance UID
callback	Progress callback function

Returns: Result containing the dataset or error information

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 596 of file s3_storage.cpp.

                                 {
  std::string object_key;
 
  {
    std::shared_lock lock(mutex_);
    auto it = index_.find(std::string{sop_instance_uid});
    if (it == index_.end()) {
      return make_error<core::dicom_dataset>(
          kObjectNotFound,
          "Instance not found: " + std::string{sop_instance_uid}, "s3_storage");
    }
    object_key = it->second.key;
  }
 
  // Download from S3
  auto download_result = client_->get_object(object_key);
  if (download_result.is_err()) {
    return make_error<core::dicom_dataset>(
        kDownloadError, "Failed to download from S3", "s3_storage");
  }
 
  const auto &data = download_result.value();
 
  // Report progress (download complete)
  if (callback) {
    callback(data.size(), data.size());
  }
 
  // Deserialize DICOM data
  auto parse_result = core::dicom_file::from_bytes(data);
  if (parse_result.is_err()) {
    return make_error<core::dicom_dataset>(
        kSerializationError,
        "Failed to parse DICOM data: " + parse_result.error().message,
        "s3_storage");
  }
 
  return parse_result.value().dataset();
}

References kcenon::pacs::core::dicom_file::from_bytes().

Here is the call graph for this function:

◆ sanitize_uid()

auto kcenon::pacs::storage::s3_storage::sanitize_uid ( std::string_view uid ) -> std::string

staticnodiscardprivate

Sanitize UID for use in S3 object key.

Parameters

uid	The UID to sanitize

Returns: Sanitized string safe for S3 key use

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 828 of file s3_storage.cpp.

                                                             {
  std::string result;
  result.reserve(uid.length());
 
  for (char c : uid) {
    // UIDs contain digits and dots, which are safe for S3 keys
    // Replace any other characters with underscore
    if (std::isalnum(static_cast<unsigned char>(c)) || c == '.') {
      result += c;
    } else {
      result += '_';
    }
  }
 
  return result;
}

References uid.

◆ store()

auto kcenon::pacs::storage::s3_storage::store ( const core::dicom_dataset & dataset ) -> VoidResult

nodiscardoverridevirtual

Store a DICOM dataset to S3.

Serializes the dataset to DICOM Part 10 format and uploads to S3. Uses multipart upload for files exceeding multipart_threshold.

Parameters

dataset The DICOM dataset to store

Returns: VoidResult Success or error information

Note: Requires Study, Series, and SOP Instance UIDs in the dataset

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 521 of file s3_storage.cpp.

                                                                     {
  return store_with_progress(dataset, nullptr);
}

◆ store_with_progress()

auto kcenon::pacs::storage::s3_storage::store_with_progress	(	const core::dicom_dataset &	dataset,
		progress_callback	callback ) -> VoidResult

nodiscard

Store with progress tracking.

Parameters

dataset	The DICOM dataset to store
callback	Progress callback function

Returns: VoidResult Success or error information

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 525 of file s3_storage.cpp.

                                                                               {
  // Extract required UIDs
  auto study_uid = dataset.get_string(core::tags::study_instance_uid);
  auto series_uid = dataset.get_string(core::tags::series_instance_uid);
  auto sop_uid = dataset.get_string(core::tags::sop_instance_uid);
 
  if (study_uid.empty() || series_uid.empty() || sop_uid.empty()) {
    return make_error<std::monostate>(
        kMissingRequiredUid,
        "Missing required UID (Study, Series, or SOP Instance UID)",
        "s3_storage");
  }
 
  // Build S3 object key
  auto object_key = build_object_key(study_uid, series_uid, sop_uid);
 
  // Create DICOM file and serialize to bytes
  auto dicom_file = core::dicom_file::create(
      dataset, encoding::transfer_syntax::explicit_vr_little_endian);
 
  auto data = dicom_file.to_bytes();
  if (data.empty()) {
    return make_error<std::monostate>(
        kSerializationError, "Failed to serialize DICOM dataset", "s3_storage");
  }
 
  // Report initial progress
  if (callback && !callback(0, data.size())) {
    return make_error<std::monostate>(kUploadError, "Upload cancelled by user",
                                      "s3_storage");
  }
 
  // Upload to S3 (use multipart for large files)
  VoidResult upload_result = ok();
  if (data.size() > config_.multipart_threshold) {
    upload_result =
        client_->multipart_upload(object_key, data, config_.part_size, callback);
  } else {
    upload_result = client_->put_object(object_key, data);
 
    // Report completion progress
    if (callback) {
      callback(data.size(), data.size());
    }
  }
 
  if (upload_result.is_err()) {
    return upload_result;
  }
 
  // Update local index
  {
    std::unique_lock lock(mutex_);
    s3_object_info info;
    info.key = object_key;
    info.sop_instance_uid = sop_uid;
    info.study_instance_uid = study_uid;
    info.series_instance_uid = series_uid;
    info.size_bytes = data.size();
    index_[sop_uid] = std::move(info);
  }
 
  return ok();
}

References kcenon::pacs::core::dicom_file::create(), kcenon::pacs::encoding::transfer_syntax::explicit_vr_little_endian, kcenon::pacs::core::tags::series_instance_uid, kcenon::pacs::core::tags::sop_instance_uid, and kcenon::pacs::core::tags::study_instance_uid.

Here is the call graph for this function:

◆ upload_multipart()

auto kcenon::pacs::storage::s3_storage::upload_multipart	(	const std::string &	key,
		const std::vector< std::uint8_t > &	data,
		progress_callback	callback ) -> VoidResult

nodiscardprivate

Execute multipart upload for large files.

Parameters

key	S3 object key
data	Data to upload
callback	Optional progress callback

Returns: VoidResult Success or error information

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 845 of file s3_storage.cpp.

                                                                            {
  return client_->multipart_upload(key, data, config_.part_size, callback);
}

◆ verify_integrity()

auto kcenon::pacs::storage::s3_storage::verify_integrity ( ) -> VoidResult

nodiscardoverridevirtual

Verify storage integrity.

Checks that all indexed objects exist in S3 and have valid ETags.

Returns: VoidResult Success if integrity is verified, error otherwise

Implements kcenon::pacs::storage::storage_interface.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 727 of file s3_storage.cpp.

                                                {
  std::vector<std::pair<std::string, std::string>> entries;
  {
    std::shared_lock lock(mutex_);
    entries.reserve(index_.size());
    for (const auto &[uid, info] : index_) {
      entries.emplace_back(uid, info.key);
    }
  }
 
  std::vector<std::string> invalid_entries;
 
  for (const auto &[uid, key] : entries) {
    if (!client_->head_object(key)) {
      invalid_entries.push_back(uid + " (object missing)");
    }
  }
 
  if (!invalid_entries.empty()) {
    std::string message = "Integrity check failed for " +
                          std::to_string(invalid_entries.size()) + " entries";
    return make_error<std::monostate>(kIntegrityError, message, "s3_storage");
  }
 
  return ok();
}

References uid.

Member Data Documentation

◆ client_

std::unique_ptr<s3_client_interface> kcenon::pacs::storage::s3_storage::client_

private

S3 client (mock for testing, AWS SDK for production)

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 392 of file s3_storage.h.

Referenced by is_connected().

◆ config_

cloud_storage_config kcenon::pacs::storage::s3_storage::config_

private

Storage configuration.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 389 of file s3_storage.h.

Referenced by bucket_name().

◆ index_

std::unordered_map<std::string, s3_object_info> kcenon::pacs::storage::s3_storage::index_

private

Mapping from SOP Instance UID to S3 object info.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 395 of file s3_storage.h.

Referenced by get_statistics().

◆ mutex_

std::shared_mutex kcenon::pacs::storage::s3_storage::mutex_

mutableprivate

Mutex for thread-safe access.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/storage/s3_storage.h.

Definition at line 398 of file s3_storage.h.

Referenced by get_statistics().

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

include/kcenon/pacs/storage/s3_storage.h
src/storage/s3_storage.cpp

Classes

Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ s3_storage() [1/3]

◆ ~s3_storage()

◆ s3_storage() [2/3]

◆ s3_storage() [3/3]

Member Function Documentation

◆ bucket_name()

◆ build_object_key()

◆ exists()

◆ find()

◆ get_object_key()

◆ get_statistics()

◆ is_connected()

◆ matches_query()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ rebuild_index()

◆ remove()

◆ retrieve()

◆ retrieve_with_progress()

◆ sanitize_uid()

◆ store()

◆ store_with_progress()

◆ upload_multipart()

◆ verify_integrity()

Member Data Documentation

◆ client_

◆ config_

◆ index_

◆ mutex_