From d905cc230c04662de4b81af94a7ce21023482c93 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 11:58:08 +0200 Subject: [PATCH 01/28] HDF5: Use explicit mapping for VDS --- reader/JFJochHDF5Reader.cpp | 72 ++++++++++-- reader/JFJochHDF5Reader.h | 3 + tests/HDF5WritingTest.cpp | 97 ++++++++++++++++ writer/HDF5Objects.cpp | 224 +++++++++++++++++++++++++++++++++++- writer/HDF5Objects.h | 24 +++- 5 files changed, 407 insertions(+), 13 deletions(-) diff --git a/reader/JFJochHDF5Reader.cpp b/reader/JFJochHDF5Reader.cpp index 2668b2e8..46bace0b 100644 --- a/reader/JFJochHDF5Reader.cpp +++ b/reader/JFJochHDF5Reader.cpp @@ -62,6 +62,37 @@ std::vector GetDimension(HDF5Object& object, const std::string& path) { return dim; } +std::vector ReadVDSImageMappings(HDF5Object &file, + const std::string &dataset_name) { + HDF5DataSet dataset(file, dataset_name); + HDF5Dcpl dcpl(dataset); + auto mappings = dcpl.GetVirtualMappings(); + + if (mappings.empty()) + throw JFJochException(JFJochExceptionCategory::HDF5, + dataset_name + " is not a virtual dataset"); + + for (const auto &mapping: mappings) { + if (mapping.dataset.empty()) + throw JFJochException(JFJochExceptionCategory::HDF5, + "VDS mapping has empty source dataset name"); + if (mapping.virtual_start.size() != 3) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Only 3D image VDS mappings are supported"); + } + + return mappings; +} + +std::string ResolveRelativeToMaster(const std::string &directory, + const std::string &filename) { + std::filesystem::path path(filename); + if (path.is_absolute() || directory.empty()) + return filename; + + return (std::filesystem::path(directory) / path).string(); +} + template void JFJochHDF5Reader::ReadVector(std::vector &v, HDF5Object &file, @@ -104,6 +135,10 @@ void JFJochHDF5Reader::ReadFile(const std::string& filename) { master_file = std::make_shared(filename); dataset->experiment = default_experiment; + std::filesystem::path master_path(filename); + master_file_directory = master_path.parent_path().string(); + vds_data_mappings.clear(); + dataset->arm_date = master_file->GetString("/entry/start_time"); dataset->experiment.FilePrefix(dataset_name(filename)); @@ -115,19 +150,19 @@ void JFJochHDF5Reader::ReadFile(const std::string& filename) { size_t image_size_x = 0; size_t image_size_y = 0; - if (master_file->Exists("/entry/data/data")) - format = FileWriterFormat::NXmxVDS; - else if (master_file->Exists("/entry/data/data_000001")) { - format = FileWriterFormat::NXmxLegacy; - } + if (master_file->Exists("/entry/data/data")) { + HDF5DataSet data_dataset(*master_file, "/entry/data/data"); + HDF5Dcpl dcpl(data_dataset); + data_layout = dcpl.GetLayout(); - if (format == FileWriterFormat::NXmxVDS ) { auto dim = GetDimension(*master_file, "/entry/data/data"); number_of_images = dim[0]; image_size_y = dim[1]; image_size_x = dim[2]; images_per_file = number_of_images; + if (data_layout == HDF5DataSetLayout::VIRTUAL) + vds_data_mappings = ReadVDSImageMappings(*master_file, "/entry/data/data"); if (master_file->Exists("/entry/instrument/detector/detectorSpecific/data_collection_efficiency_image")) dataset->efficiency = master_file->ReadVector( @@ -166,7 +201,12 @@ void JFJochHDF5Reader::ReadFile(const std::string& filename) { } if (master_file->Exists("/entry/image")) dataset->max_value = master_file->ReadOptVector("/entry/image/max_value"); - } else if (format == FileWriterFormat::NXmxLegacy) { + + format = FileWriterFormat::NXmxVDS; + } else if (master_file->Exists("/entry/data/data_000001")) { + format = FileWriterFormat::NXmxLegacy; + data_layout = HDF5DataSetLayout::CONTIGUOUS; + legacy_format_files.clear(); image_size_x = master_file->GetInt("/entry/instrument/detector/detectorSpecific/x_pixels_in_detector"); @@ -509,6 +549,22 @@ std::pair, uint32_t> JFJochHDF5Reader::GetImag uint32_t file_id = image_number / images_per_file; image_id = image_number % images_per_file; data_file = std::make_shared(legacy_format_files.at(file_id)); + } else if (format == FileWriterFormat::NXmxVDS && data_layout == HDF5DataSetLayout::VIRTUAL) { + const auto image = static_cast(image_number); + + for (const auto &mapping: vds_data_mappings) { + if (!mapping.ContainsVirtualImage(image)) + continue; + + image_id = static_cast(mapping.SourceImage(image)); + data_file = std::make_shared( + ResolveRelativeToMaster(master_file_directory, mapping.filename) + ); + return {std::move(data_file), image_id}; + } + + throw JFJochException(JFJochExceptionCategory::HDF5, + "Image not covered by /entry/data/data VDS mappings"); } else { image_id = image_number; data_file = master_file; @@ -774,6 +830,8 @@ void JFJochHDF5Reader::Close() { master_file = {}; number_of_images = 0; legacy_format_files.clear(); + vds_data_mappings.clear(); + master_file_directory.clear(); SetStartMessage({}); } diff --git a/reader/JFJochHDF5Reader.h b/reader/JFJochHDF5Reader.h index 3068e243..49e7e137 100644 --- a/reader/JFJochHDF5Reader.h +++ b/reader/JFJochHDF5Reader.h @@ -9,10 +9,13 @@ class JFJochHDF5Reader : public JFJochReader { FileWriterFormat format = FileWriterFormat::NoFile; + HDF5DataSetLayout data_layout = HDF5DataSetLayout::CONTIGUOUS; std::shared_ptr master_file; std::vector legacy_format_files; + std::vector vds_data_mappings; + std::string master_file_directory; size_t images_per_file = 1; size_t number_of_images = 0; diff --git a/tests/HDF5WritingTest.cpp b/tests/HDF5WritingTest.cpp index 32e95ae8..eb4206bd 100644 --- a/tests/HDF5WritingTest.cpp +++ b/tests/HDF5WritingTest.cpp @@ -1344,3 +1344,100 @@ TEST_CASE("FileWriter_TIFF", "[HDF5][Full]") { REQUIRE(!file_set.GetZMQAddr()); } } + +TEST_CASE("HDF5Objects_VDS_reverse_contiguous", "[HDF5][Unit]") { + { + RegisterHDF5Filter(); + + HDF5File file("scratch_vds_reverse_contiguous.h5", true); + HDF5Dcpl dcpl; + HDF5DataType data_type((int16_t) 0); + HDF5DataSpace full_space({5, 4, 3}); + + { + HDF5DataSpace source_space({2, 4, 3}); + HDF5DataSpace virtual_space({5, 4, 3}); + virtual_space.SelectHyperslab({0, 0, 0}, {2, 4, 3}); + dcpl.SetVirtual("file_000001.h5", "/entry/data/data", source_space, virtual_space); + } + + { + HDF5DataSpace source_space({3, 4, 3}); + HDF5DataSpace virtual_space({5, 4, 3}); + virtual_space.SelectHyperslab({2, 0, 0}, {3, 4, 3}); + dcpl.SetVirtual("file_000002.h5", "/entry/data/data", source_space, virtual_space); + } + + HDF5DataSet dataset(file, "/data", data_type, full_space, dcpl); + + HDF5Dcpl read_dcpl(dataset); + auto mappings = read_dcpl.GetVirtualMappings(); + + REQUIRE(mappings.size() == 2); + REQUIRE(mappings[0].ContainsVirtualImage(0)); + REQUIRE(mappings[0].ContainsVirtualImage(1)); + REQUIRE(!mappings[0].ContainsVirtualImage(2)); + CHECK(mappings[0].SourceImage(0) == 0); + CHECK(mappings[0].SourceImage(1) == 1); + + REQUIRE(mappings[1].ContainsVirtualImage(2)); + REQUIRE(mappings[1].ContainsVirtualImage(4)); + CHECK(mappings[1].SourceImage(2) == 0); + CHECK(mappings[1].SourceImage(3) == 1); + CHECK(mappings[1].SourceImage(4) == 2); + } + + remove("scratch_vds_reverse_contiguous.h5"); + REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); +} + +TEST_CASE("HDF5Objects_VDS_reverse_strided", "[HDF5][Unit]") { + { + RegisterHDF5Filter(); + + HDF5File file("scratch_vds_reverse_strided.h5", true); + HDF5Dcpl dcpl; + HDF5DataType data_type((int16_t) 0); + HDF5DataSpace full_space({6, 4, 3}); + + { + HDF5DataSpace source_space({3, 4, 3}); + HDF5DataSpace virtual_space({6, 4, 3}); + virtual_space.SelectHyperslabWithStride({0, 0, 0}, {3, 4, 3}, {2, 1, 1}); + dcpl.SetVirtual("file_even.h5", "/entry/data/data", source_space, virtual_space); + } + + { + HDF5DataSpace source_space({3, 4, 3}); + HDF5DataSpace virtual_space({6, 4, 3}); + virtual_space.SelectHyperslabWithStride({1, 0, 0}, {3, 4, 3}, {2, 1, 1}); + dcpl.SetVirtual("file_odd.h5", "/entry/data/data", source_space, virtual_space); + } + + HDF5DataSet dataset(file, "/data", data_type, full_space, dcpl); + + HDF5Dcpl read_dcpl(dataset); + auto mappings = read_dcpl.GetVirtualMappings(); + + REQUIRE(mappings.size() == 2); + + REQUIRE(mappings[0].ContainsVirtualImage(0)); + REQUIRE(mappings[0].ContainsVirtualImage(2)); + REQUIRE(mappings[0].ContainsVirtualImage(4)); + REQUIRE(!mappings[0].ContainsVirtualImage(1)); + CHECK(mappings[0].SourceImage(0) == 0); + CHECK(mappings[0].SourceImage(2) == 1); + CHECK(mappings[0].SourceImage(4) == 2); + + REQUIRE(mappings[1].ContainsVirtualImage(1)); + REQUIRE(mappings[1].ContainsVirtualImage(3)); + REQUIRE(mappings[1].ContainsVirtualImage(5)); + REQUIRE(!mappings[1].ContainsVirtualImage(0)); + CHECK(mappings[1].SourceImage(1) == 0); + CHECK(mappings[1].SourceImage(3) == 1); + CHECK(mappings[1].SourceImage(5) == 2); + } + + remove("scratch_vds_reverse_strided.h5"); + REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); +} \ No newline at end of file diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index b0c540e5..06cd4166 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -231,23 +231,26 @@ bool HDF5DataType::IsFloat() const { HDF5Dcpl::HDF5Dcpl() : HDF5Id() { id = H5Pcreate(H5P_DATASET_CREATE); ndim = 0; + layout = HDF5DataSetLayout::CONTIGUOUS; } HDF5Dcpl::HDF5Dcpl(const HDF5DataSet &data_set) : HDF5Id() { id = H5Dget_create_plist(data_set.GetID()); // Check if chunking is enabled - H5D_layout_t layout = H5Pget_layout(id); - if (layout != H5D_CHUNKED) { - ndim = 0; - } else { + H5D_layout_t h5_layout = H5Pget_layout(id); + if (h5_layout == H5D_VIRTUAL) + layout = HDF5DataSetLayout::VIRTUAL; + else if (h5_layout == H5D_CHUNKED) { + layout = HDF5DataSetLayout::CHUNKED; ndim = H5Pget_chunk(id, 0, nullptr); if (ndim <= 0) { H5Pclose(id); throw JFJochException(JFJochExceptionCategory::HDF5, "Error getting number of chunk dimensions"); } - } + } else + layout = HDF5DataSetLayout::CONTIGUOUS; } HDF5Dcpl::~HDF5Dcpl() { @@ -255,6 +258,7 @@ HDF5Dcpl::~HDF5Dcpl() { } void HDF5Dcpl::SetChunking(const std::vector &dims) { + layout = HDF5DataSetLayout::CHUNKED; if ((dims.empty()) || dims[0] == 0) throw JFJochException(JFJochExceptionCategory::HDF5, "Value dimension cannot be 0"); ndim = dims.size(); @@ -298,11 +302,16 @@ void HDF5Dcpl::SetFillValueU16(uint16_t val) { } void HDF5Dcpl::SetVirtual(const std::string &path, const std::string &dataset, const HDF5DataSpace &src_dataspace, const HDF5DataSpace &dest_dataspace) { + layout = HDF5DataSetLayout::VIRTUAL; std::string filename = ExtractFilename(path); if (H5Pset_virtual(id, dest_dataspace.GetID(), filename.c_str(), dataset.c_str(), src_dataspace.GetID()) < 0) throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot set virtual mapping"); } +HDF5DataSetLayout HDF5Dcpl::GetLayout() const { + return layout; +} + HDF5Fapl::HDF5Fapl() : HDF5Id() { id = H5Pcreate(H5P_FILE_ACCESS); } @@ -995,3 +1004,208 @@ std::string HDF5Object::GetLinkedFileName(const std::string& name) const { return s; } + + +namespace { + std::vector GetDataspaceDimensions(hid_t dataspace_id) { + const int ndims = H5Sget_simple_extent_ndims(dataspace_id); + if (ndims < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot read dataspace dimensions"); + + std::vector dims(ndims); + if (ndims > 0 && H5Sget_simple_extent_dims(dataspace_id, dims.data(), nullptr) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot read dataspace dimensions"); + + return dims; + } + + void GetRegularSelection(hid_t dataspace_id, + std::vector &start, + std::vector &stride, + std::vector &count, + std::vector &block) { + const auto dims = GetDataspaceDimensions(dataspace_id); + + const H5S_sel_type selection_type = H5Sget_select_type(dataspace_id); + if (selection_type == H5S_SEL_ALL) { + start.clear(); + stride.clear(); + count.clear(); + block.clear(); + return; + } + + start.assign(dims.size(), 0); + stride.assign(dims.size(), 1); + count.assign(dims.size(), 1); + block = dims; + + if (selection_type != H5S_SEL_HYPERSLABS) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Only regular hyperslab VDS selections are supported"); + + if (H5Sis_regular_hyperslab(dataspace_id) <= 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Only regular hyperslab VDS selections are supported"); + + if (H5Sget_regular_hyperslab(dataspace_id, + start.data(), + stride.data(), + count.data(), + block.data()) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot decode VDS hyperslab selection"); + } + + bool ContainsInRegularHyperslab(hsize_t value, + hsize_t start, + hsize_t stride, + hsize_t count, + hsize_t block) { + for (hsize_t i = 0; i < count; i++) { + const hsize_t block_start = start + i * stride; + if ((value >= block_start) && (value < block_start + block)) + return true; + } + return false; + } + + hsize_t IndexInRegularHyperslab(hsize_t value, + hsize_t start, + hsize_t stride, + hsize_t count, + hsize_t block) { + for (hsize_t i = 0; i < count; i++) { + const hsize_t block_start = start + i * stride; + if ((value >= block_start) && (value < block_start + block)) + return i * block + (value - block_start); + } + + throw JFJochException(JFJochExceptionCategory::HDF5, + "Image is not part of VDS hyperslab"); + } + + hsize_t ValueFromRegularHyperslabIndex(hsize_t index, + hsize_t start, + hsize_t stride, + hsize_t count, + hsize_t block) { + if (index >= count * block) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Source image is outside of VDS source hyperslab"); + + const hsize_t block_number = index / block; + const hsize_t in_block = index % block; + return start + block_number * stride + in_block; + } +} + +bool HDF5VirtualDatasetMapping::ContainsVirtualImage(hsize_t image_number) const { + if (virtual_start.empty() || virtual_stride.empty() || virtual_count.empty() || virtual_block.empty()) + return false; + + return ContainsInRegularHyperslab(image_number, + virtual_start[0], + virtual_stride[0], + virtual_count[0], + virtual_block[0]); +} + +hsize_t HDF5VirtualDatasetMapping::SourceImage(hsize_t image_number) const { + if (!ContainsVirtualImage(image_number)) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Image is outside of VDS mapping"); + + const hsize_t source_index = IndexInRegularHyperslab(image_number, + virtual_start[0], + virtual_stride[0], + virtual_count[0], + virtual_block[0]); + + if (source_start.empty() || source_stride.empty() || source_count.empty() || source_block.empty()) + return source_index; + + return ValueFromRegularHyperslabIndex(source_index, + source_start[0], + source_stride[0], + source_count[0], + source_block[0]); +} + + +std::vector HDF5Dcpl::GetVirtualMappings() const { + size_t mapping_count = 0; + + if (H5Pget_virtual_count(id, &mapping_count) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get number of VDS mappings"); + if (mapping_count < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get number of VDS mappings"); + + std::vector ret; + ret.reserve(static_cast(mapping_count)); + + for (size_t i = 0; i < static_cast(mapping_count); i++) { + HDF5VirtualDatasetMapping mapping; + + const ssize_t filename_size = H5Pget_virtual_filename(id, i, nullptr, 0); + if (filename_size < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS source filename size"); + + std::vector filename(filename_size + 1, '\0'); + if (H5Pget_virtual_filename(id, i, filename.data(), filename.size()) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS source filename"); + mapping.filename = filename.data(); + + const ssize_t dataset_size = H5Pget_virtual_dsetname(id, i, nullptr, 0); + if (dataset_size < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS source dataset size"); + + std::vector dataset(dataset_size + 1, '\0'); + if (H5Pget_virtual_dsetname(id, i, dataset.data(), dataset.size()) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS source dataset"); + mapping.dataset = dataset.data(); + + const hid_t virtual_space = H5Pget_virtual_vspace(id, i); + if (virtual_space < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS virtual dataspace"); + + const hid_t source_space = H5Pget_virtual_srcspace(id, i); + if (source_space < 0) { + H5Sclose(virtual_space); + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot get VDS source dataspace"); + } + + try { + GetRegularSelection(virtual_space, + mapping.virtual_start, + mapping.virtual_stride, + mapping.virtual_count, + mapping.virtual_block); + + GetRegularSelection(source_space, + mapping.source_start, + mapping.source_stride, + mapping.source_count, + mapping.source_block); + } catch (...) { + H5Sclose(source_space); + H5Sclose(virtual_space); + throw; + } + + H5Sclose(source_space); + H5Sclose(virtual_space); + + ret.emplace_back(std::move(mapping)); + } + + return ret; +} \ No newline at end of file diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index 09a0c48e..3fda329c 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -19,6 +19,24 @@ extern std::mutex hdf5_mutex; class HDF5DataSet; +struct HDF5VirtualDatasetMapping { + std::string filename; + std::string dataset; + + std::vector virtual_start; + std::vector virtual_stride; + std::vector virtual_count; + std::vector virtual_block; + + std::vector source_start; + std::vector source_stride; + std::vector source_count; + std::vector source_block; + + bool ContainsVirtualImage(hsize_t image_number) const; + hsize_t SourceImage(hsize_t image_number) const; +}; + class HDF5Id { protected: hid_t id; @@ -70,8 +88,11 @@ public: ~HDF5DataType(); }; +enum class HDF5DataSetLayout {CONTIGUOUS, CHUNKED, VIRTUAL}; + class HDF5Dcpl : public HDF5Id { uint8_t ndim = 0; + HDF5DataSetLayout layout = HDF5DataSetLayout::CONTIGUOUS; public: HDF5Dcpl(); HDF5Dcpl(const HDF5DataSet& data_set); @@ -87,7 +108,8 @@ public: void SetCompression(CompressionAlgorithm algorithm, size_t block_size); void SetVirtual(const std::string& filename, const std::string& dataset, const HDF5DataSpace& src_dataspace, const HDF5DataSpace& virtual_dataspace); - + HDF5DataSetLayout GetLayout() const; + std::vector GetVirtualMappings() const; uint8_t GetNumOfDimensions() const; }; -- 2.52.0 From 4fc4f0736e7f51ec48b0136cf9ad93e0bc9a4b1a Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 12:44:59 +0200 Subject: [PATCH 02/28] jfjoch_test: Add tests for reading raw image from VDS and integrated datasets --- tests/JFJochReaderTest.cpp | 118 ++++++++++++++++++++++++++++++++++++- 1 file changed, 117 insertions(+), 1 deletion(-) diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp index 9abb8401..3b94a52f 100644 --- a/tests/JFJochReaderTest.cpp +++ b/tests/JFJochReaderTest.cpp @@ -1497,7 +1497,7 @@ TEST_CASE("JFJochReader_NXmxIntegrated", "[HDF5][Full]") { REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); } -TEST_CASE("JFJochReader_GetRawImage", "[HDF5][Full]") { +TEST_CASE("JFJochReader_GetRawImage_NXmxLegacy", "[HDF5][Full]") { DiffractionExperiment x(DetJF(1)); x.FilePrefix("test_read_raw_image").ImagesPerTrigger(4).OverwriteExistingFiles(true); @@ -1554,4 +1554,120 @@ TEST_CASE("JFJochReader_GetRawImage", "[HDF5][Full]") { remove("test_read_raw_image_data_000002.h5"); // No leftover HDF5 objects REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); +} + +TEST_CASE("JFJochReader_GetRawImage_VDS", "[HDF5][Full]") { + DiffractionExperiment x(DetJF(1)); + + x.FilePrefix("test_read_raw_image").ImagesPerTrigger(4).OverwriteExistingFiles(true); + x.BitDepthImage(16).ImagesPerFile(2).SetFileWriterFormat(FileWriterFormat::NXmxVDS).PixelSigned(true) + .IndexingAlgorithm(IndexingAlgorithmEnum::FFT); + x.Compression(CompressionAlgorithm::BSHUF_ZSTD); + + std::vector image(x.GetPixelsNum()); + for (int i = 0; i < image.size(); i++) + image[i] = static_cast((i * 7 + 33) % UINT16_MAX); + + RegisterHDF5Filter(); + JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_ZSTD); + auto compressed_image = compressor.Compress(image); + { + StartMessage start_message; + x.FillMessage(start_message); + FileWriter file_set(start_message); + + for (int i = 0; i < x.GetImageNum(); i++) { + DataMessage message{}; + message.image = CompressedImage(compressed_image, x.GetXPixelsNum(), x.GetYPixelsNum(), + CompressedImageMode::Int16, CompressionAlgorithm::BSHUF_ZSTD); + message.number = i; + REQUIRE_NOTHROW(file_set.WriteHDF5(message)); + } + EndMessage end_message; + end_message.max_image_number = x.GetImageNum(); + file_set.WriteHDF5(end_message); + file_set.Finalize(); + } + { + JFJochHDF5Reader reader; + REQUIRE_NOTHROW(reader.ReadFile("test_read_raw_image_master.h5")); + auto dataset = reader.GetDataset(); + CHECK(dataset->experiment.GetImageNum() == 4); + + std::shared_ptr reader_image; + for (int i = 0; i < 4; i++) { + REQUIRE_NOTHROW(reader_image = reader.GetRawImage(i)); + + CHECK(reader_image->image.GetMode() == CompressedImageMode::Int16); + CHECK(reader_image->image.GetCompressionAlgorithm() == CompressionAlgorithm::BSHUF_ZSTD); + CHECK(reader_image->image.GetWidth() == x.GetXPixelsNum()); + CHECK(reader_image->image.GetHeight() == x.GetYPixelsNum()); + CHECK(reader_image->image.GetCompressedSize() == compressed_image.size()); + CHECK(reader_image->image.GetCompressed() == reader_image->image_buffer.data()); + REQUIRE(reader_image->image_buffer.size() == compressed_image.size()); + CHECK(memcmp(reader_image->image_buffer.data(), compressed_image.data(), compressed_image.size()) == 0); + } + } + remove("test_read_raw_image_master.h5"); + remove("test_read_raw_image_data_000001.h5"); + remove("test_read_raw_image_data_000002.h5"); +// No leftover HDF5 objects + REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); +} + +TEST_CASE("JFJochReader_GetRawImage_Integrated", "[HDF5][Full]") { + DiffractionExperiment x(DetJF(1)); + + x.FilePrefix("test_read_raw_image").ImagesPerTrigger(4).OverwriteExistingFiles(true); + x.BitDepthImage(16).ImagesPerFile(2).SetFileWriterFormat(FileWriterFormat::NXmxIntegrated).PixelSigned(true) + .IndexingAlgorithm(IndexingAlgorithmEnum::FFT); + x.Compression(CompressionAlgorithm::BSHUF_ZSTD); + + std::vector image(x.GetPixelsNum()); + for (int i = 0; i < image.size(); i++) + image[i] = static_cast((i * 7 + 33) % UINT16_MAX); + + RegisterHDF5Filter(); + JFJochBitShuffleCompressor compressor(CompressionAlgorithm::BSHUF_ZSTD); + auto compressed_image = compressor.Compress(image); + { + StartMessage start_message; + x.FillMessage(start_message); + FileWriter file_set(start_message); + + for (int i = 0; i < x.GetImageNum(); i++) { + DataMessage message{}; + message.image = CompressedImage(compressed_image, x.GetXPixelsNum(), x.GetYPixelsNum(), + CompressedImageMode::Int16, CompressionAlgorithm::BSHUF_ZSTD); + message.number = i; + REQUIRE_NOTHROW(file_set.WriteHDF5(message)); + } + EndMessage end_message; + end_message.max_image_number = x.GetImageNum(); + file_set.WriteHDF5(end_message); + file_set.Finalize(); + } + { + JFJochHDF5Reader reader; + REQUIRE_NOTHROW(reader.ReadFile("test_read_raw_image_master.h5")); + auto dataset = reader.GetDataset(); + CHECK(dataset->experiment.GetImageNum() == 4); + + std::shared_ptr reader_image; + for (int i = 0; i < 4; i++) { + REQUIRE_NOTHROW(reader_image = reader.GetRawImage(i)); + + CHECK(reader_image->image.GetMode() == CompressedImageMode::Int16); + CHECK(reader_image->image.GetCompressionAlgorithm() == CompressionAlgorithm::BSHUF_ZSTD); + CHECK(reader_image->image.GetWidth() == x.GetXPixelsNum()); + CHECK(reader_image->image.GetHeight() == x.GetYPixelsNum()); + CHECK(reader_image->image.GetCompressedSize() == compressed_image.size()); + CHECK(reader_image->image.GetCompressed() == reader_image->image_buffer.data()); + REQUIRE(reader_image->image_buffer.size() == compressed_image.size()); + CHECK(memcmp(reader_image->image_buffer.data(), compressed_image.data(), compressed_image.size()) == 0); + } + } + remove("test_read_raw_image_master.h5"); +// No leftover HDF5 objects + REQUIRE(H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); } \ No newline at end of file -- 2.52.0 From 87079ce04af903b1b89f2f7ef7da30b192bbed52 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 12:45:43 +0200 Subject: [PATCH 03/28] FileWriterSettings: NXmxVDS is the default way of saving data --- common/FileWriterSettings.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/FileWriterSettings.h b/common/FileWriterSettings.h index be2cfeaf..e9011e68 100644 --- a/common/FileWriterSettings.h +++ b/common/FileWriterSettings.h @@ -7,7 +7,7 @@ #include "JFJochMessages.h" class FileWriterSettings { - FileWriterFormat hdf5_master_format_version = FileWriterFormat::NXmxLegacy; + FileWriterFormat hdf5_master_format_version = FileWriterFormat::NXmxVDS; bool overwrite_files = false; public: FileWriterSettings &OverwriteExistingFiles(bool input); -- 2.52.0 From 829cad084789f9a677bd749f79762616dbaed006 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 13:27:38 +0200 Subject: [PATCH 04/28] jfjoch_test: Fix tests after change for default NXmxVDS --- tests/HDF5WritingTest.cpp | 2 +- tests/JFJochReaderTest.cpp | 6 +++--- writer/HDF5Objects.cpp | 34 +++++++++++++++++++--------------- writer/HDF5Objects.h | 11 ++++++++--- 4 files changed, 31 insertions(+), 22 deletions(-) diff --git a/tests/HDF5WritingTest.cpp b/tests/HDF5WritingTest.cpp index eb4206bd..ac140c9c 100644 --- a/tests/HDF5WritingTest.cpp +++ b/tests/HDF5WritingTest.cpp @@ -698,7 +698,7 @@ TEST_CASE("HDF5DataType", "[HDF5]") { TEST_CASE("HDF5Writer_Link", "[HDF5][Full]") { DiffractionExperiment x(DetJF(1)); - x.ImagesPerTrigger(7).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION).FilePrefix("link"); + x.ImagesPerTrigger(7).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION).FilePrefix("link").SetFileWriterFormat(FileWriterFormat::NXmxLegacy); x.OverwriteExistingFiles(true); { RegisterHDF5Filter(); diff --git a/tests/JFJochReaderTest.cpp b/tests/JFJochReaderTest.cpp index 3b94a52f..3807a470 100644 --- a/tests/JFJochReaderTest.cpp +++ b/tests/JFJochReaderTest.cpp @@ -273,13 +273,13 @@ TEST_CASE("JFJochReader_Goniometer", "[HDF5][Full]") { DataMessage message{}; for (int i = 0; i < 5; i++) { message.image = CompressedImage(image, x.GetXPixelsNum(), x.GetYPixelsNum()); - message.number = 0; + message.number = i; REQUIRE_NOTHROW(file_set.WriteHDF5(message)); } EndMessage end_message; - end_message.max_image_number = 4; + end_message.max_image_number = 5; file_set.WriteHDF5(end_message); file_set.Finalize(); @@ -337,7 +337,7 @@ TEST_CASE("JFJochReader_GridScan", "[HDF5][Full]") { } EndMessage end_message; - end_message.max_image_number = 4; + end_message.max_image_number = 5; file_set.WriteHDF5(end_message); file_set.Finalize(); diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index 06cd4166..6c0d0cc0 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -26,23 +26,27 @@ HDF5Id::HDF5Id(const HDF5Id &other) { } } +HDF5DataSpace::HDF5DataSpace(ScalarTag) : HDF5Id() { + id = H5Screate(H5S_SCALAR); + if (id < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot create scalar dataspace"); + + ndims = 0; +} + HDF5DataSpace::HDF5DataSpace(const std::vector &dims, const std::vector &max_dims) : HDF5Id() { if (dims.empty()) throw JFJochException(JFJochExceptionCategory::HDF5, "Dimension vector empty"); - if ((dims.size() == 1) && (dims[0] == 1)) - id = H5Screate(H5S_SCALAR); - else { - if (max_dims.empty()) { - if (dims[0] == 0) - throw JFJochException(JFJochExceptionCategory::HDF5, "Value dimension cannot be 0"); + if (max_dims.empty()) { + if (dims[0] == 0) + throw JFJochException(JFJochExceptionCategory::HDF5, "Value dimension cannot be 0"); - id = H5Screate_simple(dims.size(), dims.data(), nullptr); - } else { - if (max_dims.size() != dims.size()) - throw JFJochException(JFJochExceptionCategory::HDF5, "Discrepancy in size of dims/max_dims"); - id = H5Screate_simple(dims.size(), dims.data(), max_dims.data()); - } + id = H5Screate_simple(dims.size(), dims.data(), nullptr); + } else { + if (max_dims.size() != dims.size()) + throw JFJochException(JFJochExceptionCategory::HDF5, "Discrepancy in size of dims/max_dims"); + id = H5Screate_simple(dims.size(), dims.data(), max_dims.data()); } if (id < 0) throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot create dataspace"); @@ -326,7 +330,7 @@ void HDF5Fapl::SetVersionTo1p10orNewer() { template static HDF5Object& WriteOrCreateScalarAttr(HDF5Object& object, const std::string& name, const T& val) { - HDF5DataSpace dataspace; + HDF5DataSpace dataspace(HDF5DataSpace::Scalar); HDF5DataType datatype(val); hid_t attr_id = -1; @@ -373,7 +377,7 @@ static HDF5Object& WriteOrCreateScalarAttr(HDF5Object& object, const std::string } HDF5Object & HDF5Object::Attr(const std::string &name, const std::string &val) { - HDF5DataSpace dataspace; + HDF5DataSpace dataspace(HDF5DataSpace::Scalar); HDF5DataType datatype(val); hid_t attr_id = -1; @@ -656,7 +660,7 @@ std::unique_ptr HDF5Object::SaveScalar(const std::string &name, con std::unique_ptr HDF5Object::SaveScalar(const std::string &name, const char *val) { HDF5DataType data_type(val); - HDF5DataSpace data_space({1}); + HDF5DataSpace data_space(HDF5DataSpace::Scalar); auto dataset = std::make_unique(*this, name, data_type, data_space); dataset->Write(data_type, val); return dataset; diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index 3fda329c..f006f039 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -53,6 +53,11 @@ public: class HDF5DataSpace : public HDF5Id { uint8_t ndims = 1; public: + struct ScalarTag {}; + static constexpr ScalarTag Scalar{}; + + explicit HDF5DataSpace(ScalarTag); + explicit HDF5DataSpace(const std::vector& dims = {1}, const std::vector &max_dims = {}); explicit HDF5DataSpace(const HDF5DataSet& data_set); uint8_t GetNumOfDimensions() const; @@ -347,7 +352,7 @@ public: inline std::unique_ptr SaveScalar(const HDF5Object& parent, const std::string &name, const char* val) { HDF5DataType data_type(val); - HDF5DataSpace data_space({1}); + HDF5DataSpace data_space(HDF5DataSpace::Scalar); auto dataset = std::make_unique(parent, name, data_type, data_space); dataset->Write(data_type, val); return dataset; @@ -359,7 +364,7 @@ inline std::unique_ptr SaveScalar(const HDF5Object& parent, const s template std::unique_ptr SaveScalar(const HDF5Object& parent, const std::string &name, T val) { HDF5DataType data_type(val); - HDF5DataSpace data_space({1}); + HDF5DataSpace data_space(HDF5DataSpace::Scalar); auto dataset = std::make_unique(parent, name, data_type, data_space); dataset->Write(data_type, &val); return dataset; @@ -367,7 +372,7 @@ template std::unique_ptr SaveScalar(const HDF5Object& par template std::unique_ptr HDF5Object::SaveScalar(const std::string &name, T val) { HDF5DataType data_type(val); - HDF5DataSpace data_space({1}); + HDF5DataSpace data_space(HDF5DataSpace::Scalar); auto dataset = std::make_unique(*this, name, data_type, data_space); dataset->Write(data_type, &val); return dataset; -- 2.52.0 From 5407e3e189a83c3fe7ea5a22228f1580ee07e388 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Mon, 4 May 2026 10:59:12 +0200 Subject: [PATCH 05/28] HDF5: Add cleaner way of handling object destruction (explicit Close() for file and dataset, all destructors have HDF5 TRY blocks) --- writer/HDF5Objects.cpp | 94 ++++++++++++++++++++++++++++++++++++++---- writer/HDF5Objects.h | 2 + 2 files changed, 88 insertions(+), 8 deletions(-) diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index 6c0d0cc0..616a5d6d 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -94,7 +94,12 @@ void HDF5DataSpace::SelectHyperslabWithStride(const std::vector &start, } HDF5DataSpace::~HDF5DataSpace() { - if (id >= 0) H5Sclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Sclose(id); + } H5E_END_TRY; + id = -1; + } } uint8_t HDF5DataSpace::GetNumOfDimensions() const { @@ -208,7 +213,12 @@ HDF5DataType::HDF5DataType(const HDF5DataSet &data_set) :HDF5Id() { } HDF5DataType::~HDF5DataType() { - if (id >= 0) H5Tclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Tclose(id); + } H5E_END_TRY; + id = -1; + } } size_t HDF5DataType::GetElemSize() const { @@ -258,7 +268,12 @@ HDF5Dcpl::HDF5Dcpl(const HDF5DataSet &data_set) : HDF5Id() { } HDF5Dcpl::~HDF5Dcpl() { - if (id >= 0) H5Pclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Pclose(id); + } H5E_END_TRY; + id = -1; + } } void HDF5Dcpl::SetChunking(const std::vector &dims) { @@ -321,7 +336,12 @@ HDF5Fapl::HDF5Fapl() : HDF5Id() { } HDF5Fapl::~HDF5Fapl() { - H5Pclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Pclose(id); + } H5E_END_TRY; + id = -1; + } } void HDF5Fapl::SetVersionTo1p10orNewer() { @@ -698,7 +718,12 @@ HDF5Group::HDF5Group(const HDF5Object& parent, const char *name) : HDF5Object() } HDF5Group::~HDF5Group() { - H5Gclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Gclose(id); + } H5E_END_TRY; + id = -1; + } } HDF5File::HDF5File(const std::string& filename, bool v1_10) : HDF5Object() { @@ -711,8 +736,37 @@ HDF5File::HDF5File(const std::string& filename, bool v1_10) : HDF5Object() { throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot open/create data HDF5 file " + filename); } +void HDF5File::Close() { + if (id < 0) + return; + + // Invalidate first; if anything below fails (e.g. ENOSPC) we must NOT + // leave a live id behind for the destructor or later code to touch. + const hid_t local_id = id; + id = -1; + + herr_t flush_err = 0; + H5E_BEGIN_TRY { + flush_err = H5Fflush(local_id, H5F_SCOPE_GLOBAL); + } H5E_END_TRY; + + herr_t close_err = 0; + H5E_BEGIN_TRY { + close_err = H5Fclose(local_id); + } H5E_END_TRY; + + if (flush_err < 0 || close_err < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Failed to flush/close HDF5 file (likely no space left on device)"); +} + HDF5File::~HDF5File() { - if (id >= 0) H5Fclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Fclose(id); + } H5E_END_TRY; + id = -1; + } } void HDF5File::Delete(const std::string& path) { @@ -726,7 +780,10 @@ HDF5ReadOnlyFile::HDF5ReadOnlyFile(const std::string &filename) { } HDF5ReadOnlyFile::~HDF5ReadOnlyFile() { - if (id >= 0) H5Fclose(id); + if (id >= 0) { + H5E_BEGIN_TRY {H5Fclose(id); } H5E_END_TRY; + id = -1; + } } HDF5DataSet::HDF5DataSet(const HDF5Object &parent, const std::string &name, const HDF5DataType &data_type, @@ -812,8 +869,29 @@ std::string HDF5DataSet::ReadString() const { return buffer; } +void HDF5DataSet::Close() { + if (id < 0) + return; + + const hid_t local_id = id; + id = -1; + + herr_t err = 0; + H5E_BEGIN_TRY { + err = H5Dclose(local_id); + } H5E_END_TRY; + + if (err < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot close HDF5 dataset"); +} + HDF5DataSet::~HDF5DataSet() { - if (id >= 0) H5Dclose(id); + if (id >= 0) { + H5E_BEGIN_TRY { + H5Dclose(id); + } H5E_END_TRY; + id = -1; + } } void HDF5DataSet::ReadDirectChunk(std::vector &val, const std::vector &offset) { diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index f006f039..0408fbe5 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -196,6 +196,7 @@ public: explicit HDF5File(const std::string& filename, bool v1_10 = false); ~HDF5File(); void Delete(const std::string& path); + void Close(); }; class HDF5ReadOnlyFile : public HDF5Object { @@ -348,6 +349,7 @@ public: } std::string ReadString() const; + void Close(); }; inline std::unique_ptr SaveScalar(const HDF5Object& parent, const std::string &name, const char* val) { -- 2.52.0 From b7136cc92dbc4a26f80279686cd972e55e958e5a Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Mon, 4 May 2026 11:06:04 +0200 Subject: [PATCH 06/28] HDF5: Destructor of HDF5DataFile doesn't copy file, it actually removes it --- writer/HDF5DataFile.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/writer/HDF5DataFile.cpp b/writer/HDF5DataFile.cpp index 07486f4f..3117565c 100644 --- a/writer/HDF5DataFile.cpp +++ b/writer/HDF5DataFile.cpp @@ -75,8 +75,10 @@ std::optional HDF5DataFile::Close() { data_set ->Attr("image_nr_low", (int32_t) (image_low + 1)) .Attr("image_nr_high", (int32_t) (image_low + 1 + max_image_number)); + data_set->Close(); data_set.reset(); } + data_file->Close(); data_file.reset(); if (manage_file && (!std::filesystem::exists(filename.c_str()) || overwrite)) @@ -89,13 +91,17 @@ std::optional HDF5DataFile::Close() { ret.total_images = nimages; ret.filename = filename; ret.file_number = file_number + 1; + + return ret; } HDF5DataFile::~HDF5DataFile() { if (data_file) { try { - Close(); + data_set->Close(); + data_file->Close(); + std::filesystem::remove(tmp_filename); } catch (const std::exception &e) { std::cerr << "HDF5DataFile::~HDF5DataFile: " << e.what() << std::endl; } catch (...) { -- 2.52.0 From 3a81c8839453060cbe646aa1a7fd473f82325efb Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Mon, 4 May 2026 11:23:18 +0200 Subject: [PATCH 07/28] HDF5: Improvements in data file and master file safety. --- writer/HDF5DataFile.cpp | 30 ++++++++++++++++++++++-------- writer/HDF5NXmx.cpp | 29 +++++++++++++++++++++++++++-- 2 files changed, 49 insertions(+), 10 deletions(-) diff --git a/writer/HDF5DataFile.cpp b/writer/HDF5DataFile.cpp index 3117565c..49626a9f 100644 --- a/writer/HDF5DataFile.cpp +++ b/writer/HDF5DataFile.cpp @@ -78,11 +78,22 @@ std::optional HDF5DataFile::Close() { data_set->Close(); data_set.reset(); } - data_file->Close(); - data_file.reset(); - if (manage_file && (!std::filesystem::exists(filename.c_str()) || overwrite)) - std::rename(tmp_filename.c_str(), filename.c_str()); + if (manage_file ) { + data_file->Close(); + data_file.reset(); + + if (std::filesystem::exists(filename) && !overwrite) + throw JFJochException(JFJochExceptionCategory::FileWriteError, "File already exists"); + std::error_code ec; + std::filesystem::rename(tmp_filename, filename, ec); + if (ec) + throw JFJochException(JFJochExceptionCategory::FileWriteError, + "Cannot rename temporary HDF5 file " + tmp_filename + + " to " + filename + ": " + ec.message()); + } else { + data_file.reset(); + } closed = true; @@ -92,16 +103,19 @@ std::optional HDF5DataFile::Close() { ret.filename = filename; ret.file_number = file_number + 1; - return ret; } HDF5DataFile::~HDF5DataFile() { if (data_file) { try { - data_set->Close(); - data_file->Close(); - std::filesystem::remove(tmp_filename); + data_set.reset(); + data_set_image_number.reset(); + data_file.reset(); + if (manage_file) { + std::error_code ec; + std::filesystem::remove(tmp_filename, ec); + } } catch (const std::exception &e) { std::cerr << "HDF5DataFile::~HDF5DataFile: " << e.what() << std::endl; } catch (...) { diff --git a/writer/HDF5NXmx.cpp b/writer/HDF5NXmx.cpp index 961634b7..f92a67ca 100644 --- a/writer/HDF5NXmx.cpp +++ b/writer/HDF5NXmx.cpp @@ -54,8 +54,13 @@ NXmx::NXmx(const StartMessage &start) } NXmx::~NXmx() { - if (!std::filesystem::exists(filename.c_str()) || overwrite) - std::rename(tmp_filename.c_str(), filename.c_str()); + try { + if (hdf5_file) { + hdf5_file.reset(); + std::error_code ec; + std::filesystem::remove(tmp_filename, ec); + } + } catch (...) {} } @@ -630,6 +635,9 @@ void NXmx::Attenuator(const StartMessage &start) { } void NXmx::WriteCalibration(const CompressedImage &image) { + if (!hdf5_file) + throw JFJochException(JFJochExceptionCategory::FileWriteError, "HDF5 file already closed"); + if (!calibration_group_created) { calibration_group_created = true; HDF5Group(*hdf5_file, "/entry/instrument/detector/calibration").NXClass("NXcollection"); @@ -655,6 +663,8 @@ void NXmx::SaveCBORImage(const std::string &hdf5_path, const CompressedImage &im dataset->Write(data_type, image.GetCompressed()); else dataset->WriteDirectChunk(image.GetCompressed(), image.GetCompressedSize(), {0, 0}); + + dataset->Close(); } void NXmx::AzimuthalIntegration(const StartMessage &start, const EndMessage &end) { @@ -689,6 +699,8 @@ void NXmx::ADUHistogram(const EndMessage &end) { } void NXmx::Finalize(const EndMessage &end) { + if (!hdf5_file) + throw JFJochException(JFJochExceptionCategory::FileWriteError, "HDF5 file already closed"); if (end.end_date) { hdf5_file->Attr("file_time", end.end_date.value()); hdf5_file->SaveScalar("/entry/end_time", end.end_date.value()); @@ -733,6 +745,19 @@ void NXmx::Finalize(const EndMessage &end) { if (!end.scale_factor.empty()) SaveVector(*hdf5_file, "/entry/MX/imageScaleFactor", end.scale_factor); + + hdf5_file->Close(); + hdf5_file.reset(); + + if (std::filesystem::exists(filename) && !overwrite) + throw JFJochException(JFJochExceptionCategory::FileWriteError, "File already exists"); + + std::error_code ec; + std::filesystem::rename(tmp_filename, filename, ec); + if (ec) + throw JFJochException(JFJochExceptionCategory::FileWriteError, + "Cannot rename temporary HDF5 master file " + tmp_filename + + " to " + filename + ": " + ec.message()); } void NXmx::UserData(const StartMessage &start) { -- 2.52.0 From 643de4d69095ab5fe947fa4172f27fd99ee9eeb2 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 13:33:34 +0200 Subject: [PATCH 08/28] jfjoch_test: Improve tests (ensure overwrite is ON) --- tests/HDF5WritingTest.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/HDF5WritingTest.cpp b/tests/HDF5WritingTest.cpp index ac140c9c..1269b116 100644 --- a/tests/HDF5WritingTest.cpp +++ b/tests/HDF5WritingTest.cpp @@ -514,7 +514,7 @@ TEST_CASE("HDF5Writer_Socket", "[HDF5][Full]") { .PhotonEnergy_keV(12.07).SetUnitCell(UnitCell{.a = 97, .b = 97, .c = 38, .alpha= 90, .beta = 90, .gamma = 90}) .SpaceGroupNumber(96).RunNumber(345).ExperimentGroup("p12345").SampleName("lysozyme").RunName("run1"); - x.ImportDatasetSettings(d); + x.ImportDatasetSettings(d).OverwriteExistingFiles(true); std::vector spots; StartMessage start_message; @@ -627,7 +627,7 @@ TEST_CASE("HDF5Writer_Rad_Int_Profile", "[HDF5][Full]") { std::vector rad_int_profile(mapping.GetBinNumber(), 4.0); std::vector rad_int_avg(mapping.GetBinNumber(), 0.33); - x.FilePrefix("test02_1p10_rad_int").ImagesPerTrigger(5).ImagesPerFile(3).Compression(CompressionAlgorithm::NO_COMPRESSION); + x.FilePrefix("test02_1p10_rad_int").ImagesPerTrigger(5).ImagesPerFile(3).Compression(CompressionAlgorithm::NO_COMPRESSION).OverwriteExistingFiles(true); StartMessage start_message; x.FillMessage(start_message); start_message.az_int_bin_to_q = mapping.GetBinToQ(); @@ -1225,7 +1225,7 @@ TEST_CASE("HDF5Writer_Calibration", "[HDF5][Full]") { TEST_CASE("HDF5Writer_Link_zero_images", "[HDF5][Full]") { DiffractionExperiment x(DetJF(1)); - x.ImagesPerTrigger(5).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION).FilePrefix("link_zero"); + x.ImagesPerTrigger(5).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION).FilePrefix("link_zero").OverwriteExistingFiles(true); { RegisterHDF5Filter(); -- 2.52.0 From 4f01f413d8eba4aee5e353ebd30f38561978b88f Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 13:51:36 +0200 Subject: [PATCH 09/28] jfjoch_test: Add overwrite ON for further tests --- tests/JFJochReceiverProcessingTest.cpp | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/JFJochReceiverProcessingTest.cpp b/tests/JFJochReceiverProcessingTest.cpp index 82aff890..8bae482a 100644 --- a/tests/JFJochReceiverProcessingTest.cpp +++ b/tests/JFJochReceiverProcessingTest.cpp @@ -1455,7 +1455,7 @@ TEST_CASE("JFJochIntegrationTest_HDF5FilePusher", "[JFJochReceiver]") { DiffractionExperiment experiment(DetJF4M()); experiment.ImagesPerTrigger(5).NumTriggers(1).UseInternalPacketGenerator(true) .FilePrefix("HDF5FilePusherTest").JungfrauConvPhotonCnt(true) - .DetectorDistance_mm(75).BeamY_pxl(1136).BeamX_pxl(1090).IncidentEnergy_keV(12.4); + .DetectorDistance_mm(75).BeamY_pxl(1136).BeamX_pxl(1090).IncidentEnergy_keV(12.4).OverwriteExistingFiles(true); JFCalibration calibration(experiment); PixelMask pixel_mask(experiment); @@ -1490,7 +1490,8 @@ TEST_CASE("JFJochIntegrationTest_HDF5FilePusher_republish", "[JFJochReceiver]") DiffractionExperiment experiment(DetJF4M()); experiment.ImagesPerTrigger(5).NumTriggers(1).UseInternalPacketGenerator(true) .FilePrefix("HDF5FilePusherRepublishTest").JungfrauConvPhotonCnt(true) - .DetectorDistance_mm(75).BeamY_pxl(1136).BeamX_pxl(1090).IncidentEnergy_keV(12.4); + .DetectorDistance_mm(75).BeamY_pxl(1136).BeamX_pxl(1090).IncidentEnergy_keV(12.4) + .OverwriteExistingFiles(true); PixelMask pixel_mask(experiment); @@ -1585,7 +1586,7 @@ TEST_CASE("JFJochIntegrationTest_HDF5FilePusher_Raw", "[JFJochReceiver]") { DiffractionExperiment experiment(DetJF(1)); experiment.ImagesPerTrigger(5).NumTriggers(1).UseInternalPacketGenerator(true) - .FilePrefix("HDF5FilePusherTest_Raw"); + .FilePrefix("HDF5FilePusherTest_Raw").OverwriteExistingFiles(true); experiment.Raw(); PixelMask pixel_mask(experiment); -- 2.52.0 From cffc86395744164ceb324697e4fda368d0d79ffd Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 14:21:28 +0200 Subject: [PATCH 10/28] CMake: Remove assertions with NDEBUG by for release version --- CMakeLists.txt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 7ec69f9b..c49e0644 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,8 +8,8 @@ SET(CMAKE_POLICY_DEFAULT_CMP0077 NEW) SET(CMAKE_CXX_STANDARD 20) SET(CMAKE_CXX_STANDARD_REQUIRED True) -SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion") -SET(CMAKE_C_FLAGS_RELEASE "-O3") +SET(CMAKE_CXX_FLAGS_RELEASE "-O3 -Wno-deprecated-enum-enum-conversion -DNDEBUG") +SET(CMAKE_C_FLAGS_RELEASE "-O3 -DNDEBUG") SET(JFJOCH_WRITER_ONLY OFF CACHE BOOL "Compile HDF5 writer only") SET(JFJOCH_INSTALL_DRIVER_SOURCE OFF CACHE BOOL "Install kernel driver source (ignored if building writer only; necessary for RPM building)") -- 2.52.0 From aa217860059379f38c778c00c51428a0115792fe Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 15:53:20 +0200 Subject: [PATCH 11/28] jfjoch_hdf5_test: Finalize dataset --- tools/jfjoch_hdf5_test.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tools/jfjoch_hdf5_test.cpp b/tools/jfjoch_hdf5_test.cpp index f9f4d2d7..d87c176e 100644 --- a/tools/jfjoch_hdf5_test.cpp +++ b/tools/jfjoch_hdf5_test.cpp @@ -164,6 +164,7 @@ int main(int argc, char **argv) { EndMessage end_message; end_message.max_image_number = x.GetImageNum(); fileset->WriteHDF5(end_message); + fileset->Finalize(); // Clean close dataset fileset.reset(); // Ensure data file is closed here auto end_time = std::chrono::system_clock::now(); auto elapsed = std::chrono::duration_cast(end_time - start_time); -- 2.52.0 From cae8577c855b6c93f182db90d4db4da5b753c4eb Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 16:04:35 +0200 Subject: [PATCH 12/28] HDF5: Use strong file close FAPL --- writer/HDF5Objects.cpp | 6 ++++++ writer/HDF5Objects.h | 1 + 2 files changed, 7 insertions(+) diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index 616a5d6d..e5314c40 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -348,6 +348,10 @@ void HDF5Fapl::SetVersionTo1p10orNewer() { H5Pset_libver_bounds(id, H5F_LIBVER_V110, H5F_LIBVER_LATEST); } +void HDF5Fapl::SetCloseStrong() { + H5Pset_fclose_degree(id, H5F_CLOSE_STRONG); +} + template static HDF5Object& WriteOrCreateScalarAttr(HDF5Object& object, const std::string& name, const T& val) { HDF5DataSpace dataspace(HDF5DataSpace::Scalar); @@ -731,6 +735,8 @@ HDF5File::HDF5File(const std::string& filename, bool v1_10) : HDF5Object() { if (v1_10) fapl.SetVersionTo1p10orNewer(); + fapl.SetCloseStrong(); + id = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl.GetID()); if (id < 0) throw JFJochException(JFJochExceptionCategory::HDF5, "Cannot open/create data HDF5 file " + filename); diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index 0408fbe5..eea8ded9 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -123,6 +123,7 @@ public: HDF5Fapl(); ~HDF5Fapl(); void SetVersionTo1p10orNewer(); + void SetCloseStrong(); }; class HDF5Object : public HDF5Id { -- 2.52.0 From 2dc9a043bec3d281eb5cd6f933ccfed65b2329a9 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 16:08:23 +0200 Subject: [PATCH 13/28] enospc tests (not sure how useful) --- tests/CMakeLists.txt | 14 ++- tests/enospc_shim.c | 153 ++++++++++++++++++++++++++++++ tests/jfjoch_hdf5_enospc_test.cpp | 44 +++++++++ 3 files changed, 209 insertions(+), 2 deletions(-) create mode 100644 tests/enospc_shim.c create mode 100644 tests/jfjoch_hdf5_enospc_test.cpp diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index d5083ddb..a0e1756b 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -69,6 +69,16 @@ ADD_EXECUTABLE(jfjoch_test XDSPluginTest.cpp ) -target_link_libraries(jfjoch_test Catch2WithMain JFJochBroker JFJochReceiver JFJochReader JFJochWriter JFJochImageAnalysis JFJochCommon JFJochHLSSimulation JFJochPreview - jfjoch_xds_plugin) +target_link_libraries(jfjoch_test Catch2WithMain JFJochBroker JFJochReceiver JFJochReader JFJochWriter + JFJochImageAnalysis JFJochCommon JFJochHLSSimulation JFJochPreview + jfjoch_xds_plugin) target_include_directories(jfjoch_test PRIVATE .) + +find_package(Threads REQUIRED) + +add_library(enospc_shim MODULE enospc_shim.c) +target_link_libraries(enospc_shim PRIVATE Threads::Threads dl) +set_target_properties(enospc_shim PROPERTIES PREFIX "" POSITION_INDEPENDENT_CODE ON) # remove "lib" + +ADD_EXECUTABLE(jfjoch_hdf5_enospc_test jfjoch_hdf5_enospc_test.cpp) +target_link_libraries(jfjoch_hdf5_enospc_test Catch2WithMain JFJochWriter) \ No newline at end of file diff --git a/tests/enospc_shim.c b/tests/enospc_shim.c new file mode 100644 index 00000000..fec12797 --- /dev/null +++ b/tests/enospc_shim.c @@ -0,0 +1,153 @@ +// SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include + +// Function pointers to real syscalls +static ssize_t (*real_pwrite64) (int, const void *, size_t, __off64_t) = NULL; + +// State +static size_t total_written = 0; +static size_t fail_after = 0; + +// Thread safety (important in real tests) +static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER; + +// Initialize real symbols and config +__attribute__((constructor)) +static void init(void) { + real_pwrite64 = dlsym(RTLD_NEXT, "pwrite64"); + + const char* env = getenv("ENOSPC_AFTER"); + if (env) { + fail_after = strtoull(env, NULL, 10); + } else { + fail_after = 10ULL * 1024 * 1024; // default: 10 MB + } + + printf("ENOSPC shim loaded with limit %lu bytes\n", fail_after); +} +/* +// Common helper +static int should_fail(size_t upcoming) { + if (fail_after == 0) return 0; + + if (total_written >= fail_after) return 1; + + if (total_written + upcoming > fail_after) { + // Simulate partial write exhaustion: + // allow some bytes, then next call fails + return 0; + } + + return 0; +} + +// ---- write ---- +ssize_t write(int fd, const void *buf, size_t count) { + pthread_mutex_lock(&lock); + + printf("write %lu bytes\n", count); + if (total_written >= fail_after) { + pthread_mutex_unlock(&lock); + errno = ENOSPC; + return -1; + } + + pthread_mutex_unlock(&lock); + + ssize_t ret = real_write(fd, buf, count); + + if (ret > 0) { + pthread_mutex_lock(&lock); + total_written += ret; + pthread_mutex_unlock(&lock); + } + + return ret; +} + +// ---- pwrite ---- +ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset) { + pthread_mutex_lock(&lock); + + printf("pwrite %lu bytes\n", count); + if (total_written >= fail_after) { + pthread_mutex_unlock(&lock); + errno = ENOSPC; + return -1; + } + + pthread_mutex_unlock(&lock); + + ssize_t ret = real_pwrite(fd, buf, count, offset); + + if (ret > 0) { + pthread_mutex_lock(&lock); + total_written += ret; + pthread_mutex_unlock(&lock); + } + + return ret; +} + +// ---- writev ---- +ssize_t writev(int fd, const struct iovec *iov, int iovcnt) { + size_t total = 0; + for (int i = 0; i < iovcnt; i++) { + total += iov[i].iov_len; + } + + printf("writev %lu bytes\n", total); + + pthread_mutex_lock(&lock); + + if (total_written >= fail_after) { + pthread_mutex_unlock(&lock); + errno = ENOSPC; + return -1; + } + + pthread_mutex_unlock(&lock); + + ssize_t ret = real_writev(fd, iov, iovcnt); + + if (ret > 0) { + pthread_mutex_lock(&lock); + total_written += ret; + pthread_mutex_unlock(&lock); + } + pwrite64() + return ret; +} */ + +ssize_t pwrite64(int fd, const void *buf, size_t count, off_t offset) { + pthread_mutex_lock(&lock); + + printf("pwrite64 %lu bytes\n", count); + + if (total_written >= fail_after) { + pthread_mutex_unlock(&lock); + errno = ENOSPC; + return -1; + } + + pthread_mutex_unlock(&lock); + + ssize_t ret = real_pwrite64(fd, buf, count, offset); + + if (ret > 0) { + pthread_mutex_lock(&lock); + total_written += ret; + pthread_mutex_unlock(&lock); + } + + return ret; +} \ No newline at end of file diff --git a/tests/jfjoch_hdf5_enospc_test.cpp b/tests/jfjoch_hdf5_enospc_test.cpp new file mode 100644 index 00000000..2b167dba --- /dev/null +++ b/tests/jfjoch_hdf5_enospc_test.cpp @@ -0,0 +1,44 @@ +// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only + +// Run with LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test + +#include +#include "../writer/HDF5Objects.h" +#include "../writer/FileWriter.h" +#include "../common/DiffractionExperiment.h" + +TEST_CASE("HDF5File_enospc") { + auto file = std::make_unique("enospc_test.h5"); + + std::vector small_vector(2056), large_vector(40 * 1024 * 1024); + REQUIRE_NOTHROW(file->SaveVector("/small", small_vector)); + REQUIRE_NOTHROW(file->SaveVector("/large1", large_vector)); + REQUIRE_THROWS(file->SaveVector("/large2", large_vector)); + REQUIRE_NOTHROW(file.reset()); +} + +TEST_CASE("FileWriter_enospc") { + { + RegisterHDF5Filter(); + DiffractionExperiment x(DetJF4M()); + + x.FilePrefix("test02_1p10").ImagesPerTrigger(5).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION); + StartMessage start_message; + x.FillMessage(start_message); + + FileWriter file_set(start_message); + std::vector image(x.GetPixelsNum()); + + DataMessage message{}; + message.image = CompressedImage(image, x.GetXPixelsNum(), x.GetYPixelsNum()); + message.number = 0; + REQUIRE_NOTHROW(file_set.Write(message)); + message.number = 1; + REQUIRE_THROWS(file_set.Write(message)); + message.number = 2; + REQUIRE_THROWS(file_set.Write(message)); + } + // No leftover HDF5 objects + REQUIRE (H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); +} -- 2.52.0 From 3464346f5390b8b1440c42616c085f94acb351ca Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Tue, 5 May 2026 16:52:16 +0200 Subject: [PATCH 14/28] HDF5: poisoned file sec2 VFD driver (to be tested!!!!) --- writer/CMakeLists.txt | 6 +- writer/H5FDpoison_sec2.c | 556 +++++++++++++++++++++++++++++++++++++++ writer/H5FDpoison_sec2.h | 30 +++ writer/HDF5Objects.cpp | 22 ++ writer/HDF5Objects.h | 1 + 5 files changed, 614 insertions(+), 1 deletion(-) create mode 100644 writer/H5FDpoison_sec2.c create mode 100644 writer/H5FDpoison_sec2.h diff --git a/writer/CMakeLists.txt b/writer/CMakeLists.txt index 645a2372..95215a06 100644 --- a/writer/CMakeLists.txt +++ b/writer/CMakeLists.txt @@ -1,4 +1,8 @@ -ADD_LIBRARY(JFJochHDF5Wrappers STATIC HDF5Objects.cpp HDF5Objects.h ../compression/bitshuffle/bshuf_h5filter.c) +ADD_LIBRARY(JFJochHDF5Wrappers STATIC + HDF5Objects.cpp HDF5Objects.h + H5FDpoison_sec2.c H5FDpoison_sec2.h + ../compression/bitshuffle/bshuf_h5filter.c + ../compression/bitshuffle/bshuf_h5filter.h) set_target_properties(JFJochHDF5Wrappers PROPERTIES POSITION_INDEPENDENT_CODE ON) TARGET_LINK_LIBRARIES(JFJochHDF5Wrappers Compression hdf5-static) diff --git a/writer/H5FDpoison_sec2.c b/writer/H5FDpoison_sec2.c new file mode 100644 index 00000000..61633111 --- /dev/null +++ b/writer/H5FDpoison_sec2.c @@ -0,0 +1,556 @@ +#include "H5FDpoison_sec2.h" + +#include +#include +#include +#include + +#include +#include + +#define H5FD_POISON_SEC2_MAXADDR (((haddr_t)1 << (8 * sizeof(HDoff_t) - 1)) - 1) + +#ifndef H5FD_POISON_SEC2_NAME +#define H5FD_POISON_SEC2_NAME "poison_sec2" +#endif + +#ifndef H5FD_POISON_SEC2_VALUE +#define H5FD_POISON_SEC2_VALUE ((H5FD_class_value_t)(H5_VFD_RESERVED + 42)) +#endif + +typedef struct H5FD_poison_sec2_t { + H5FD_t pub; + + H5FD_t *inner; + + hbool_t poisoned; + int poison_errno; + + char *filename; +} H5FD_poison_sec2_t; + +static hid_t H5FD_POISON_SEC2_id_g = H5I_INVALID_HID; + +static H5FD_poison_sec2_cb_t H5FD_poison_sec2_cb_g = NULL; +static void *H5FD_poison_sec2_cb_ud_g = NULL; + +static herr_t H5FD_poison_sec2_fail_fast(H5FD_poison_sec2_t *file) { + if (!file->poisoned) + return 0; + + errno = file->poison_errno != 0 ? file->poison_errno : EIO; + return -1; +} + +static herr_t H5FD_poison_sec2_mark_poisoned( + H5FD_poison_sec2_t *file, + const char *operation +) { + if (!file->poisoned) { + file->poisoned = true; + file->poison_errno = errno != 0 ? errno : EIO; + + if (H5FD_poison_sec2_cb_g != NULL) { + H5FD_poison_sec2_cb_g( + file->filename != NULL ? file->filename : "", + operation, + file->poison_errno, + H5FD_poison_sec2_cb_ud_g + ); + } + } + + errno = file->poison_errno != 0 ? file->poison_errno : EIO; + return -1; +} + +static hid_t H5FD_poison_sec2_make_inner_fapl(hid_t fapl_id) { + hid_t inner_fapl = H5I_INVALID_HID; + + /* + * Copy the caller's FAPL so generic file-access settings are preserved: + * alignment, metadata block size, sieve buffer size, file locking, + * libver bounds, close degree, etc. + * + * Then replace only the VFD driver with sec2. This prevents recursive + * poison_sec2 -> poison_sec2 opens while keeping the rest of the FAPL. + */ + if (fapl_id == H5P_DEFAULT) + inner_fapl = H5Pcreate(H5P_FILE_ACCESS); + else + inner_fapl = H5Pcopy(fapl_id); + + if (inner_fapl < 0) + return H5I_INVALID_HID; + + if (H5Pset_fapl_sec2(inner_fapl) < 0) { + H5Pclose(inner_fapl); + return H5I_INVALID_HID; + } + + return inner_fapl; +} + +static H5FD_t *H5FD_poison_sec2_open( + const char *name, + unsigned flags, + hid_t fapl_id, + haddr_t maxaddr +) { + H5FD_poison_sec2_t *file = NULL; + hid_t inner_fapl = H5I_INVALID_HID; + + file = (H5FD_poison_sec2_t *)calloc(1, sizeof(H5FD_poison_sec2_t)); + if (file == NULL) + return NULL; + + file->inner = NULL; + file->poisoned = false; + file->poison_errno = 0; + file->filename = name != NULL ? strdup(name) : NULL; + + inner_fapl = H5FD_poison_sec2_make_inner_fapl(fapl_id); + if (inner_fapl < 0) { + free(file->filename); + free(file); + return NULL; + } + + file->inner = H5FDopen(name, flags, inner_fapl, maxaddr); + + H5Pclose(inner_fapl); + + if (file->inner == NULL) { + free(file->filename); + free(file); + return NULL; + } + + return (H5FD_t *)file; +} + +static herr_t H5FD_poison_sec2_close(H5FD_t *_file) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner != NULL) { + H5E_BEGIN_TRY { + H5FDclose(file->inner); + } H5E_END_TRY; + + file->inner = NULL; + } + + free(file->filename); + free(file); + + return 0; +} + +static int H5FD_poison_sec2_cmp(const H5FD_t *_f1, const H5FD_t *_f2) { + const H5FD_poison_sec2_t *f1 = (const H5FD_poison_sec2_t *)_f1; + const H5FD_poison_sec2_t *f2 = (const H5FD_poison_sec2_t *)_f2; + + if (f1->inner == NULL && f2->inner == NULL) + return 0; + if (f1->inner == NULL) + return -1; + if (f2->inner == NULL) + return 1; + + return H5FDcmp(f1->inner, f2->inner); +} + +static herr_t H5FD_poison_sec2_query(const H5FD_t *_file, unsigned long *flags) { + (void)_file; + + if (flags == NULL) + return -1; + + *flags = H5FD_FEAT_AGGREGATE_METADATA | + H5FD_FEAT_ACCUMULATE_METADATA | + H5FD_FEAT_DATA_SIEVE | + H5FD_FEAT_AGGREGATE_SMALLDATA; + + return 0; +} + +static haddr_t H5FD_poison_sec2_get_eoa(const H5FD_t *_file, H5FD_mem_t type) { + const H5FD_poison_sec2_t *file = (const H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return HADDR_UNDEF; + + return H5FDget_eoa(file->inner, type); +} + +static herr_t H5FD_poison_sec2_set_eoa( + H5FD_t *_file, + H5FD_mem_t type, + haddr_t addr +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + /* + * EOA is logical state, not necessarily physical I/O. + * Do not fail-fast this unless inner sec2 itself rejects it. + */ + if (H5FDset_eoa(file->inner, type, addr) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "set_eoa"); + + return 0; +} + +static haddr_t H5FD_poison_sec2_get_eof(const H5FD_t *_file, H5FD_mem_t type) { + const H5FD_poison_sec2_t *file = (const H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return HADDR_UNDEF; + + return H5FDget_eof(file->inner, type); +} + +static herr_t H5FD_poison_sec2_get_handle( + H5FD_t *_file, + hid_t fapl, + void **file_handle +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + /* + * Preserve sec2 semantics: return the native handle from inner sec2. + */ + return H5FDget_vfd_handle(file->inner, fapl, file_handle); +} + +static herr_t H5FD_poison_sec2_read( + H5FD_t *_file, + H5FD_mem_t type, + hid_t dxpl_id, + haddr_t addr, + size_t size, + void *buf +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + return H5FDread(file->inner, type, dxpl_id, addr, size, buf); +} + +static herr_t H5FD_poison_sec2_write( + H5FD_t *_file, + H5FD_mem_t type, + hid_t dxpl_id, + haddr_t addr, + size_t size, + const void *buf +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + + if (H5FDwrite(file->inner, type, dxpl_id, addr, size, buf) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "write"); + + return 0; +} + + +static herr_t H5FD_poison_sec2_read_vector( + H5FD_t *_file, + hid_t dxpl_id, + uint32_t count, + H5FD_mem_t types[], + haddr_t addrs[], + size_t sizes[], + void *bufs[] +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + return H5FDread_vector( + file->inner, + dxpl_id, + count, + types, + addrs, + sizes, + bufs + ); +} + +static herr_t H5FD_poison_sec2_write_vector( + H5FD_t *_file, + hid_t dxpl_id, + uint32_t count, + H5FD_mem_t types[], + haddr_t addrs[], + size_t sizes[], + const void *bufs[] +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + + if (H5FDwrite_vector( + file->inner, + dxpl_id, + count, + types, + addrs, + sizes, + bufs + ) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "write_vector"); + + return 0; +} + +static herr_t H5FD_poison_sec2_read_selection( + H5FD_t *_file, + H5FD_mem_t type, + hid_t dxpl_id, + size_t count, + hid_t mem_spaces[], + hid_t file_spaces[], + haddr_t offsets[], + size_t element_sizes[], + void *bufs[] +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + return H5FDread_selection( + file->inner, + type, + dxpl_id, + (uint32_t)count, + mem_spaces, + file_spaces, + offsets, + element_sizes, + bufs + ); +} + +static herr_t H5FD_poison_sec2_write_selection( + H5FD_t *_file, + H5FD_mem_t type, + hid_t dxpl_id, + size_t count, + hid_t mem_spaces[], + hid_t file_spaces[], + haddr_t offsets[], + size_t element_sizes[], + const void *bufs[] +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + + if (H5FDwrite_selection( + file->inner, + type, + dxpl_id, + (uint32_t)count, + mem_spaces, + file_spaces, + offsets, + element_sizes, + bufs + ) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "write_selection"); + + return 0; +} + +static herr_t H5FD_poison_sec2_flush( + H5FD_t *_file, + hid_t dxpl_id, + bool closing +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + + if (H5FDflush(file->inner, dxpl_id, closing) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "flush"); + + return 0; +} + +static herr_t H5FD_poison_sec2_truncate( + H5FD_t *_file, + hid_t dxpl_id, + bool closing +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + + if (H5FDtruncate(file->inner, dxpl_id, closing) < 0) + return H5FD_poison_sec2_mark_poisoned(file, "truncate"); + + return 0; +} + +static herr_t H5FD_poison_sec2_lock(H5FD_t *_file, bool rw) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + return H5FDlock(file->inner, rw); +} + +static herr_t H5FD_poison_sec2_unlock(H5FD_t *_file) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file->inner == NULL) + return -1; + + return H5FDunlock(file->inner); +} + +static herr_t H5FD_poison_sec2_delete(const char *filename, hid_t fapl_id) { + hid_t inner_fapl = H5FD_poison_sec2_make_inner_fapl(fapl_id); + herr_t ret; + + if (inner_fapl < 0) + return -1; + + ret = H5FDdelete(filename, inner_fapl); + + H5Pclose(inner_fapl); + + return ret; +} + +static herr_t H5FD_poison_sec2_ctl( + H5FD_t *_file, + uint64_t op_code, + uint64_t flags, + const void *input, + void **output +) { + H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; + + if (file == NULL || file->inner == NULL) + return -1; + + return H5FDctl(file->inner, op_code, flags, input, output); +} + +static const H5FD_class_t H5FD_poison_sec2_class_g = { + H5FD_CLASS_VERSION, /* struct version */ + H5FD_POISON_SEC2_VALUE, /* value */ + H5FD_POISON_SEC2_NAME, /* name */ + H5FD_POISON_SEC2_MAXADDR, /* maxaddr */ + H5F_CLOSE_WEAK, /* fc_degree */ + + NULL, /* terminate */ + + NULL, /* sb_size */ + NULL, /* sb_encode */ + NULL, /* sb_decode */ + + 0, /* fapl_size */ + NULL, /* fapl_get */ + NULL, /* fapl_copy */ + NULL, /* fapl_free */ + + 0, /* dxpl_size */ + NULL, /* dxpl_copy */ + NULL, /* dxpl_free */ + + H5FD_poison_sec2_open, /* open */ + H5FD_poison_sec2_close, /* close */ + H5FD_poison_sec2_cmp, /* cmp */ + H5FD_poison_sec2_query, /* query */ + + NULL, /* get_type_map */ + NULL, /* alloc */ + NULL, /* free */ + + H5FD_poison_sec2_get_eoa, /* get_eoa */ + H5FD_poison_sec2_set_eoa, /* set_eoa */ + H5FD_poison_sec2_get_eof, /* get_eof */ + H5FD_poison_sec2_get_handle, /* get_handle */ + + H5FD_poison_sec2_read, /* read */ + H5FD_poison_sec2_write, /* write */ + + H5FD_poison_sec2_read_vector, /* read_vector */ + H5FD_poison_sec2_write_vector, /* write_vector */ + H5FD_poison_sec2_read_selection, /* read_selection */ + H5FD_poison_sec2_write_selection,/* write_selection */ + + H5FD_poison_sec2_flush, /* flush */ + H5FD_poison_sec2_truncate, /* truncate */ + + H5FD_poison_sec2_lock, /* lock */ + H5FD_poison_sec2_unlock, /* unlock */ + + H5FD_poison_sec2_delete, /* del */ + H5FD_poison_sec2_ctl, /* ctl */ + + H5FD_FLMAP_DICHOTOMY /* fl_map */ +}; + +hid_t H5FD_poison_sec2_init(void) { + if (H5FD_POISON_SEC2_id_g >= 0) + return H5FD_POISON_SEC2_id_g; + + H5FD_POISON_SEC2_id_g = H5FDregister(&H5FD_poison_sec2_class_g); + + return H5FD_POISON_SEC2_id_g; +} + +herr_t H5Pset_fapl_poison_sec2(hid_t fapl_id) { + hid_t driver_id = H5FD_poison_sec2_init(); + + if (driver_id < 0) + return -1; + + return H5Pset_driver(fapl_id, driver_id, NULL); +} + +herr_t H5FD_poison_sec2_set_callback( + H5FD_poison_sec2_cb_t cb, + void *user_data +) { + H5FD_poison_sec2_cb_g = cb; + H5FD_poison_sec2_cb_ud_g = user_data; + return 0; +} \ No newline at end of file diff --git a/writer/H5FDpoison_sec2.h b/writer/H5FDpoison_sec2.h new file mode 100644 index 00000000..edeb394d --- /dev/null +++ b/writer/H5FDpoison_sec2.h @@ -0,0 +1,30 @@ +#ifndef H5FD_POISON_SEC2_H +#define H5FD_POISON_SEC2_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + + typedef void (*H5FD_poison_sec2_cb_t)( + const char *filename, + const char *operation, + int error_number, + void *user_data + ); + + hid_t H5FD_poison_sec2_init(void); + + herr_t H5Pset_fapl_poison_sec2(hid_t fapl_id); + + herr_t H5FD_poison_sec2_set_callback( + H5FD_poison_sec2_cb_t cb, + void *user_data + ); + +#ifdef __cplusplus +} +#endif + +#endif /* H5FD_POISON_SEC2_H */ \ No newline at end of file diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index e5314c40..99921e6c 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -6,9 +6,22 @@ #include #include "HDF5Objects.h" +#include "H5FDpoison_sec2.h" std::mutex hdf5_mutex; +static void HDF5PoisonCallback( + const char *filename, + const char *operation, + int error_number, + void *user_data +) { + /* + * Mark writer failed, log, cancel acquisition, etc. + * Avoid throwing from this C callback. + */ +} + hid_t HDF5Id::GetID() const { return id; } @@ -352,6 +365,12 @@ void HDF5Fapl::SetCloseStrong() { H5Pset_fclose_degree(id, H5F_CLOSE_STRONG); } +void HDF5Fapl::SetPoisonSec2() { + if (H5Pset_fapl_poison_sec2(id) < 0) + throw JFJochException(JFJochExceptionCategory::HDF5, + "Cannot enable poisoned sec2 HDF5 VFD"); +} + template static HDF5Object& WriteOrCreateScalarAttr(HDF5Object& object, const std::string& name, const T& val) { HDF5DataSpace dataspace(HDF5DataSpace::Scalar); @@ -733,9 +752,12 @@ HDF5Group::~HDF5Group() { HDF5File::HDF5File(const std::string& filename, bool v1_10) : HDF5Object() { HDF5Fapl fapl; + H5FD_poison_sec2_init(); + H5FD_poison_sec2_set_callback(HDF5PoisonCallback, nullptr); if (v1_10) fapl.SetVersionTo1p10orNewer(); fapl.SetCloseStrong(); + fapl.SetPoisonSec2(); id = H5Fcreate(filename.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, fapl.GetID()); if (id < 0) diff --git a/writer/HDF5Objects.h b/writer/HDF5Objects.h index eea8ded9..d011b51e 100644 --- a/writer/HDF5Objects.h +++ b/writer/HDF5Objects.h @@ -124,6 +124,7 @@ public: ~HDF5Fapl(); void SetVersionTo1p10orNewer(); void SetCloseStrong(); + void SetPoisonSec2(); }; class HDF5Object : public HDF5Id { -- 2.52.0 From 8a4cd246eba8108c50a85a38f9eae32ac7d49c4e Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 18:31:58 +0200 Subject: [PATCH 15/28] HDF5: VFD handles ENOSPC OK at the moment (though FileWriter is still not 100% happy) --- tests/jfjoch_hdf5_enospc_test.cpp | 2 ++ writer/CMakeLists.txt | 2 +- writer/H5FDpoison_sec2.c | 19 ++++++++++++++----- writer/HDF5Objects.cpp | 6 ++---- 4 files changed, 19 insertions(+), 10 deletions(-) diff --git a/tests/jfjoch_hdf5_enospc_test.cpp b/tests/jfjoch_hdf5_enospc_test.cpp index 2b167dba..c43f15a0 100644 --- a/tests/jfjoch_hdf5_enospc_test.cpp +++ b/tests/jfjoch_hdf5_enospc_test.cpp @@ -16,6 +16,8 @@ TEST_CASE("HDF5File_enospc") { REQUIRE_NOTHROW(file->SaveVector("/large1", large_vector)); REQUIRE_THROWS(file->SaveVector("/large2", large_vector)); REQUIRE_NOTHROW(file.reset()); + // No leftover HDF5 objects + REQUIRE (H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); } TEST_CASE("FileWriter_enospc") { diff --git a/writer/CMakeLists.txt b/writer/CMakeLists.txt index 95215a06..72caf2d8 100644 --- a/writer/CMakeLists.txt +++ b/writer/CMakeLists.txt @@ -5,7 +5,7 @@ ADD_LIBRARY(JFJochHDF5Wrappers STATIC ../compression/bitshuffle/bshuf_h5filter.h) set_target_properties(JFJochHDF5Wrappers PROPERTIES POSITION_INDEPENDENT_CODE ON) -TARGET_LINK_LIBRARIES(JFJochHDF5Wrappers Compression hdf5-static) +TARGET_LINK_LIBRARIES(JFJochHDF5Wrappers JFJochLogger Compression hdf5-static) ADD_LIBRARY(JFJochWriter STATIC HDF5DataFile.h HDF5DataFile.cpp diff --git a/writer/H5FDpoison_sec2.c b/writer/H5FDpoison_sec2.c index 61633111..d00f4b16 100644 --- a/writer/H5FDpoison_sec2.c +++ b/writer/H5FDpoison_sec2.c @@ -241,6 +241,9 @@ static herr_t H5FD_poison_sec2_read( if (file->inner == NULL) return -1; + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + return H5FDread(file->inner, type, dxpl_id, addr, size, buf); } @@ -258,7 +261,7 @@ static herr_t H5FD_poison_sec2_write( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return -1; + return 0; if (H5FDwrite(file->inner, type, dxpl_id, addr, size, buf) < 0) return H5FD_poison_sec2_mark_poisoned(file, "write"); @@ -281,6 +284,9 @@ static herr_t H5FD_poison_sec2_read_vector( if (file->inner == NULL) return -1; + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + return H5FDread_vector( file->inner, dxpl_id, @@ -307,7 +313,7 @@ static herr_t H5FD_poison_sec2_write_vector( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return -1; + return 0; if (H5FDwrite_vector( file->inner, @@ -339,6 +345,9 @@ static herr_t H5FD_poison_sec2_read_selection( if (file->inner == NULL) return -1; + if (H5FD_poison_sec2_fail_fast(file) < 0) + return -1; + return H5FDread_selection( file->inner, type, @@ -369,7 +378,7 @@ static herr_t H5FD_poison_sec2_write_selection( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return -1; + return 0; if (H5FDwrite_selection( file->inner, @@ -398,7 +407,7 @@ static herr_t H5FD_poison_sec2_flush( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return -1; + return 0; if (H5FDflush(file->inner, dxpl_id, closing) < 0) return H5FD_poison_sec2_mark_poisoned(file, "flush"); @@ -417,7 +426,7 @@ static herr_t H5FD_poison_sec2_truncate( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return -1; + return 0; if (H5FDtruncate(file->inner, dxpl_id, closing) < 0) return H5FD_poison_sec2_mark_poisoned(file, "truncate"); diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index 99921e6c..729a3c6b 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -3,6 +3,7 @@ #include #include +#include #include #include "HDF5Objects.h" @@ -16,10 +17,7 @@ static void HDF5PoisonCallback( int error_number, void *user_data ) { - /* - * Mark writer failed, log, cancel acquisition, etc. - * Avoid throwing from this C callback. - */ + spdlog::info("HDF5 Poison callback triggered: filename={}, operation={}, error_number={}", filename, operation, error_number); } hid_t HDF5Id::GetID() const { -- 2.52.0 From e2e6fc909f0bb3921bfc21bbfdc1379cf35ed2d9 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 18:34:33 +0200 Subject: [PATCH 16/28] Gitea: Add ENOSPC test --- .gitea/workflows/build_and_test.yml | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index 3c4e8f0c..f0c8d776 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -314,18 +314,22 @@ jobs: mkdir -p build cd build cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. - ninja -j48 jfjoch_test jfjoch_hdf5_test + ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim - name: Run unit tests shell: bash run: | cd build/tests ./jfjoch_test + - name: ENOSPC test + shell: bash + run: | + cd build/tests + LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc - name: Run hdf5 test shell: bash run: | cd build/tools ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 - create-release: name: Create release runs-on: jfjoch_rocky8 -- 2.52.0 From bc41e19a706833caa98a4095fa9ea11ec8b8c6a6 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 19:36:14 +0200 Subject: [PATCH 17/28] HDF5NXmx: Improve error handling --- .gitea/workflows/build_and_test.yml | 1 + tests/jfjoch_hdf5_enospc_test.cpp | 9 ++- writer/FileWriter.cpp | 1 - writer/HDF5NXmx.cpp | 103 +++++++++++++++------------- 4 files changed, 64 insertions(+), 50 deletions(-) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index f0c8d776..50a9166b 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -325,6 +325,7 @@ jobs: run: | cd build/tests LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc + LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc - name: Run hdf5 test shell: bash run: | diff --git a/tests/jfjoch_hdf5_enospc_test.cpp b/tests/jfjoch_hdf5_enospc_test.cpp index c43f15a0..0cc7201a 100644 --- a/tests/jfjoch_hdf5_enospc_test.cpp +++ b/tests/jfjoch_hdf5_enospc_test.cpp @@ -7,6 +7,7 @@ #include "../writer/HDF5Objects.h" #include "../writer/FileWriter.h" #include "../common/DiffractionExperiment.h" +#include TEST_CASE("HDF5File_enospc") { auto file = std::make_unique("enospc_test.h5"); @@ -25,7 +26,8 @@ TEST_CASE("FileWriter_enospc") { RegisterHDF5Filter(); DiffractionExperiment x(DetJF4M()); - x.FilePrefix("test02_1p10").ImagesPerTrigger(5).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION); + x.FilePrefix("fw_enospc").ImagesPerTrigger(5).ImagesPerFile(2).Compression(CompressionAlgorithm::NO_COMPRESSION) + .SetFileWriterFormat(FileWriterFormat::NXmxVDS); StartMessage start_message; x.FillMessage(start_message); @@ -40,6 +42,11 @@ TEST_CASE("FileWriter_enospc") { REQUIRE_THROWS(file_set.Write(message)); message.number = 2; REQUIRE_THROWS(file_set.Write(message)); + + EndMessage end_message{ + .max_image_number = 3 + }; + REQUIRE_THROWS(file_set.WriteHDF5(end_message)); } // No leftover HDF5 objects REQUIRE (H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); diff --git a/writer/FileWriter.cpp b/writer/FileWriter.cpp index c7503786..4e90fd5c 100644 --- a/writer/FileWriter.cpp +++ b/writer/FileWriter.cpp @@ -15,7 +15,6 @@ FileWriter::FileWriter(const StartMessage &request) if (start_message.file_format) format = start_message.file_format.value(); - // defailt if (start_message.images_per_file <= 0) start_message.images_per_file = default_images_per_file; diff --git a/writer/HDF5NXmx.cpp b/writer/HDF5NXmx.cpp index f92a67ca..b368808b 100644 --- a/writer/HDF5NXmx.cpp +++ b/writer/HDF5NXmx.cpp @@ -699,56 +699,63 @@ void NXmx::ADUHistogram(const EndMessage &end) { } void NXmx::Finalize(const EndMessage &end) { - if (!hdf5_file) - throw JFJochException(JFJochExceptionCategory::FileWriteError, "HDF5 file already closed"); - if (end.end_date) { - hdf5_file->Attr("file_time", end.end_date.value()); - hdf5_file->SaveScalar("/entry/end_time", end.end_date.value()); - hdf5_file->SaveScalar("/entry/end_time_estimated", end.end_date.value()); - } else { - std::string time_now = time_UTC(std::chrono::system_clock::now()); - hdf5_file->Attr("file_time", time_now); - hdf5_file->SaveScalar("/entry/end_time", time_now); - hdf5_file->SaveScalar("/entry/end_time_estimated", time_now); + try { + if (!hdf5_file) + throw JFJochException(JFJochExceptionCategory::FileWriteError, "HDF5 file already closed"); + if (end.end_date) { + hdf5_file->Attr("file_time", end.end_date.value()); + hdf5_file->SaveScalar("/entry/end_time", end.end_date.value()); + hdf5_file->SaveScalar("/entry/end_time_estimated", end.end_date.value()); + } else { + std::string time_now = time_UTC(std::chrono::system_clock::now()); + hdf5_file->Attr("file_time", time_now); + hdf5_file->SaveScalar("/entry/end_time", time_now); + hdf5_file->SaveScalar("/entry/end_time_estimated", time_now); + } + + Detector(start_message, end); + Sample(start_message, end); + AzimuthalIntegration(start_message, end); + ADUHistogram(end); + + switch (start_message.file_format.value_or(FileWriterFormat::NXmxLegacy)) { + case FileWriterFormat::NXmxLegacy: + LinkToData(start_message, end); + break; + case FileWriterFormat::NXmxVDS: + LinkToData_VDS(start_message, end); + break; + case FileWriterFormat::NXmxIntegrated: + default: + break; + } + + if (end.rotation_lattice) + SaveVector(*hdf5_file, "/entry/MX/rotationLatticeIndexed", end.rotation_lattice->GetVector()) + ->Units("Angstrom"); + + if (end.rotation_lattice_type) + SaveScalar(*hdf5_file, "/entry/MX/rotationLatticeNiggliClass", end.rotation_lattice_type->niggli_class); + + if (end.indexing_rate) { + SaveScalar(*hdf5_file, "/entry/MX/imageIndexedMean", end.indexing_rate.value()); + } + if (end.bkg_estimate) { + SaveScalar(*hdf5_file, "/entry/MX/bkgEstimateMean", end.bkg_estimate.value()); + } + + if (!end.scale_factor.empty()) + SaveVector(*hdf5_file, "/entry/MX/imageScaleFactor", end.scale_factor); + + hdf5_file->Close(); + hdf5_file.reset(); + } catch (const JFJochException &e) { + hdf5_file.reset(); + std::error_code ec; + std::filesystem::remove(tmp_filename, ec); + throw; } - Detector(start_message, end); - Sample(start_message, end); - AzimuthalIntegration(start_message, end); - ADUHistogram(end); - - switch (start_message.file_format.value_or(FileWriterFormat::NXmxLegacy)) { - case FileWriterFormat::NXmxLegacy: - LinkToData(start_message, end); - break; - case FileWriterFormat::NXmxVDS: - LinkToData_VDS(start_message, end); - break; - case FileWriterFormat::NXmxIntegrated: - default: - break; - } - - if (end.rotation_lattice) - SaveVector(*hdf5_file, "/entry/MX/rotationLatticeIndexed", end.rotation_lattice->GetVector()) - ->Units("Angstrom"); - - if (end.rotation_lattice_type) - SaveScalar(*hdf5_file, "/entry/MX/rotationLatticeNiggliClass", end.rotation_lattice_type->niggli_class); - - if (end.indexing_rate) { - SaveScalar(*hdf5_file, "/entry/MX/imageIndexedMean", end.indexing_rate.value()); - } - if (end.bkg_estimate) { - SaveScalar(*hdf5_file, "/entry/MX/bkgEstimateMean", end.bkg_estimate.value()); - } - - if (!end.scale_factor.empty()) - SaveVector(*hdf5_file, "/entry/MX/imageScaleFactor", end.scale_factor); - - hdf5_file->Close(); - hdf5_file.reset(); - if (std::filesystem::exists(filename) && !overwrite) throw JFJochException(JFJochExceptionCategory::FileWriteError, "File already exists"); -- 2.52.0 From 0a291822c0967ad78732787f6d1a58d4fb772b54 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 19:47:27 +0200 Subject: [PATCH 18/28] HDF5: Remove linking spdlog from HDF5 wrapper library --- writer/CMakeLists.txt | 2 +- writer/HDF5Objects.cpp | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/writer/CMakeLists.txt b/writer/CMakeLists.txt index 72caf2d8..95215a06 100644 --- a/writer/CMakeLists.txt +++ b/writer/CMakeLists.txt @@ -5,7 +5,7 @@ ADD_LIBRARY(JFJochHDF5Wrappers STATIC ../compression/bitshuffle/bshuf_h5filter.h) set_target_properties(JFJochHDF5Wrappers PROPERTIES POSITION_INDEPENDENT_CODE ON) -TARGET_LINK_LIBRARIES(JFJochHDF5Wrappers JFJochLogger Compression hdf5-static) +TARGET_LINK_LIBRARIES(JFJochHDF5Wrappers Compression hdf5-static) ADD_LIBRARY(JFJochWriter STATIC HDF5DataFile.h HDF5DataFile.cpp diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index 729a3c6b..a6c49e1e 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -3,7 +3,7 @@ #include #include -#include +#include #include #include "HDF5Objects.h" @@ -17,7 +17,7 @@ static void HDF5PoisonCallback( int error_number, void *user_data ) { - spdlog::info("HDF5 Poison callback triggered: filename={}, operation={}, error_number={}", filename, operation, error_number); + std::cerr << "HDF5 Poison callback triggered: filename=" << filename << ", operation=" << operation << ", error_number=" << error_number << std::endl; } hid_t HDF5Id::GetID() const { -- 2.52.0 From cee04a9aef193ec30009edd7f4c72e1716c62f9f Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Tue, 5 May 2026 21:13:52 +0200 Subject: [PATCH 19/28] jfjoch_test: Set max optimization time to 30 seconds (given tests run on slow, shared machine, it doesn't make sense to time these tests, just need to know it actually works) --- tests/XtalOptimizerTest.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/tests/XtalOptimizerTest.cpp b/tests/XtalOptimizerTest.cpp index 5301ab55..f968b150 100644 --- a/tests/XtalOptimizerTest.cpp +++ b/tests/XtalOptimizerTest.cpp @@ -32,6 +32,7 @@ TEST_CASE("XtalOptimizer") { } XtalOptimizerData xtal_opt{}; + xtal_opt.max_time = 30.0; xtal_opt.latt = CrystalLattice(40.2,39.4,80.2, 90,91, 89); xtal_opt.geom.BeamX_pxl(1010).BeamY_pxl(995).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); @@ -90,6 +91,7 @@ TEST_CASE("XtalOptimizer_NoBeamCenter") { .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Monoclinic; xtal_opt.refine_beam_center = false; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); @@ -140,6 +142,7 @@ TEST_CASE("XtalOptimizer_orthorombic") { xtal_opt.latt = CrystalLattice(40.2,49.6,80.3, 90,91, 89); xtal_opt.geom.BeamX_pxl(1005).BeamY_pxl(997).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); + xtal_opt.max_time = 30.0; xtal_opt.crystal_system = gemmi::CrystalSystem::Orthorhombic; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); @@ -192,7 +195,7 @@ TEST_CASE("XtalOptimizer_triclinic") { xtal_opt.geom.BeamX_pxl(997).BeamY_pxl(1005).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Triclinic; - xtal_opt.max_time = 1.0; + xtal_opt.max_time = 36.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -245,6 +248,7 @@ TEST_CASE("XtalOptimizer_tetragonal") { xtal_opt.geom.BeamX_pxl(1010).BeamY_pxl(995).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Tetragonal; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -296,6 +300,7 @@ TEST_CASE("XtalOptimizer_hexagonal") { xtal_opt.geom.BeamX_pxl(1007).BeamY_pxl(990).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Hexagonal; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -349,6 +354,7 @@ TEST_CASE("XtalOptimizer_hexagonal_unconstrained") { xtal_opt.geom.BeamX_pxl(1002).BeamY_pxl(998).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Triclinic; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -407,6 +413,7 @@ TEST_CASE("XtalOptimizer_cubic") { xtal_opt.geom.BeamX_pxl(1007).BeamY_pxl(990).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Cubic; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -460,6 +467,7 @@ TEST_CASE("XtalOptimizer_monoclinic") { xtal_opt.geom.BeamX_pxl(1007).BeamY_pxl(990).DetectorDistance_mm(200) .PoniRot1_rad(0.01).PoniRot2_rad(0.02); xtal_opt.crystal_system = gemmi::CrystalSystem::Monoclinic; + xtal_opt.max_time = 30.0; auto start = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); auto end = std::chrono::high_resolution_clock::now(); @@ -606,6 +614,7 @@ TEST_CASE("XtalOptimizer_rotation") { xtal_opt.refine_beam_center = true; xtal_opt.refine_distance_mm = true; xtal_opt.refine_detector_angles = false; + xtal_opt.max_time = 30.0; auto t0 = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); @@ -693,6 +702,7 @@ TEST_CASE("XtalOptimizer_refine_rotation_axis") { xtal_opt.refine_distance_mm = false; xtal_opt.refine_detector_angles = false; xtal_opt.refine_rotation_axis = true; + xtal_opt.max_time = 30.0; auto t0 = std::chrono::high_resolution_clock::now(); REQUIRE(XtalOptimizer(xtal_opt, spots)); -- 2.52.0 From a5e316617489e277df498111039a2e9c1bb6d49d Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 6 May 2026 11:20:08 +0200 Subject: [PATCH 20/28] HDF5: Update VFD to have fail-pass mode --- tests/jfjoch_hdf5_enospc_test.cpp | 1 + writer/H5FDpoison_sec2.c | 141 ++++++++++++++++++++++++++---- writer/H5FDpoison_sec2.h | 42 ++++++--- writer/HDF5Objects.cpp | 42 ++++++--- 4 files changed, 185 insertions(+), 41 deletions(-) diff --git a/tests/jfjoch_hdf5_enospc_test.cpp b/tests/jfjoch_hdf5_enospc_test.cpp index 0cc7201a..1e6bbc52 100644 --- a/tests/jfjoch_hdf5_enospc_test.cpp +++ b/tests/jfjoch_hdf5_enospc_test.cpp @@ -16,6 +16,7 @@ TEST_CASE("HDF5File_enospc") { REQUIRE_NOTHROW(file->SaveVector("/small", small_vector)); REQUIRE_NOTHROW(file->SaveVector("/large1", large_vector)); REQUIRE_THROWS(file->SaveVector("/large2", large_vector)); + REQUIRE_THROWS(file->Close()); REQUIRE_NOTHROW(file.reset()); // No leftover HDF5 objects REQUIRE (H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL) == 0); diff --git a/writer/H5FDpoison_sec2.c b/writer/H5FDpoison_sec2.c index d00f4b16..e6120640 100644 --- a/writer/H5FDpoison_sec2.c +++ b/writer/H5FDpoison_sec2.c @@ -18,6 +18,8 @@ #define H5FD_POISON_SEC2_VALUE ((H5FD_class_value_t)(H5_VFD_RESERVED + 42)) #endif +#define H5FD_POISON_SEC2_LAST_ERROR_STRING_SIZE 1024 + typedef struct H5FD_poison_sec2_t { H5FD_t pub; @@ -29,11 +31,63 @@ typedef struct H5FD_poison_sec2_t { char *filename; } H5FD_poison_sec2_t; +typedef struct H5FD_poison_sec2_last_error_t { + hbool_t valid; + int error_number; + char filename[H5FD_POISON_SEC2_LAST_ERROR_STRING_SIZE]; + char operation[H5FD_POISON_SEC2_LAST_ERROR_STRING_SIZE]; +} H5FD_poison_sec2_last_error_t; + static hid_t H5FD_POISON_SEC2_id_g = H5I_INVALID_HID; static H5FD_poison_sec2_cb_t H5FD_poison_sec2_cb_g = NULL; static void *H5FD_poison_sec2_cb_ud_g = NULL; +static hbool_t H5FD_poison_sec2_fail_pass_g = false; +static H5FD_poison_sec2_last_error_t H5FD_poison_sec2_last_error_g = { + false, + 0, + "", + "" +}; + +static void H5FD_poison_sec2_clear_last_error(void) { + H5FD_poison_sec2_last_error_g.valid = false; + H5FD_poison_sec2_last_error_g.error_number = 0; + H5FD_poison_sec2_last_error_g.filename[0] = '\0'; + H5FD_poison_sec2_last_error_g.operation[0] = '\0'; +} + +static void H5FD_poison_sec2_store_last_error( + const H5FD_poison_sec2_t *file, + const char *operation, + int error_number +) { + const char *filename = file != NULL && file->filename != NULL ? file->filename : ""; + const char *op = operation != NULL ? operation : ""; + + H5FD_poison_sec2_last_error_g.valid = true; + H5FD_poison_sec2_last_error_g.error_number = error_number != 0 ? error_number : EIO; + + strncpy( + H5FD_poison_sec2_last_error_g.filename, + filename, + sizeof(H5FD_poison_sec2_last_error_g.filename) - 1 + ); + H5FD_poison_sec2_last_error_g.filename[ + sizeof(H5FD_poison_sec2_last_error_g.filename) - 1 + ] = '\0'; + + strncpy( + H5FD_poison_sec2_last_error_g.operation, + op, + sizeof(H5FD_poison_sec2_last_error_g.operation) - 1 + ); + H5FD_poison_sec2_last_error_g.operation[ + sizeof(H5FD_poison_sec2_last_error_g.operation) - 1 + ] = '\0'; +} + static herr_t H5FD_poison_sec2_fail_fast(H5FD_poison_sec2_t *file) { if (!file->poisoned) return 0; @@ -60,10 +114,16 @@ static herr_t H5FD_poison_sec2_mark_poisoned( } } + H5FD_poison_sec2_store_last_error(file, operation, file->poison_errno); + errno = file->poison_errno != 0 ? file->poison_errno : EIO; return -1; } +static herr_t H5FD_poison_sec2_write_failure_result(void) { + return H5FD_poison_sec2_fail_pass_g ? 0 : -1; +} + static hid_t H5FD_poison_sec2_make_inner_fapl(hid_t fapl_id) { hid_t inner_fapl = H5I_INVALID_HID; @@ -133,10 +193,15 @@ static herr_t H5FD_poison_sec2_close(H5FD_t *_file) { H5FD_poison_sec2_t *file = (H5FD_poison_sec2_t *)_file; if (file->inner != NULL) { + herr_t err = 0; + H5E_BEGIN_TRY { - H5FDclose(file->inner); + err = H5FDclose(file->inner); } H5E_END_TRY; + if (err < 0) + H5FD_poison_sec2_mark_poisoned(file, "close"); + file->inner = NULL; } @@ -261,15 +326,16 @@ static herr_t H5FD_poison_sec2_write( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return 0; + return H5FD_poison_sec2_write_failure_result(); - if (H5FDwrite(file->inner, type, dxpl_id, addr, size, buf) < 0) - return H5FD_poison_sec2_mark_poisoned(file, "write"); + if (H5FDwrite(file->inner, type, dxpl_id, addr, size, buf) < 0) { + H5FD_poison_sec2_mark_poisoned(file, "write"); + return H5FD_poison_sec2_write_failure_result(); + } return 0; } - static herr_t H5FD_poison_sec2_read_vector( H5FD_t *_file, hid_t dxpl_id, @@ -313,7 +379,7 @@ static herr_t H5FD_poison_sec2_write_vector( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return 0; + return H5FD_poison_sec2_write_failure_result(); if (H5FDwrite_vector( file->inner, @@ -323,8 +389,10 @@ static herr_t H5FD_poison_sec2_write_vector( addrs, sizes, bufs - ) < 0) - return H5FD_poison_sec2_mark_poisoned(file, "write_vector"); + ) < 0) { + H5FD_poison_sec2_mark_poisoned(file, "write_vector"); + return H5FD_poison_sec2_write_failure_result(); + } return 0; } @@ -378,7 +446,7 @@ static herr_t H5FD_poison_sec2_write_selection( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return 0; + return H5FD_poison_sec2_write_failure_result(); if (H5FDwrite_selection( file->inner, @@ -390,8 +458,10 @@ static herr_t H5FD_poison_sec2_write_selection( offsets, element_sizes, bufs - ) < 0) - return H5FD_poison_sec2_mark_poisoned(file, "write_selection"); + ) < 0) { + H5FD_poison_sec2_mark_poisoned(file, "write_selection"); + return H5FD_poison_sec2_write_failure_result(); + } return 0; } @@ -407,10 +477,12 @@ static herr_t H5FD_poison_sec2_flush( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return 0; + return H5FD_poison_sec2_write_failure_result(); - if (H5FDflush(file->inner, dxpl_id, closing) < 0) - return H5FD_poison_sec2_mark_poisoned(file, "flush"); + if (H5FDflush(file->inner, dxpl_id, closing) < 0) { + H5FD_poison_sec2_mark_poisoned(file, "flush"); + return H5FD_poison_sec2_write_failure_result(); + } return 0; } @@ -426,10 +498,12 @@ static herr_t H5FD_poison_sec2_truncate( return -1; if (H5FD_poison_sec2_fail_fast(file) < 0) - return 0; + return H5FD_poison_sec2_write_failure_result(); - if (H5FDtruncate(file->inner, dxpl_id, closing) < 0) - return H5FD_poison_sec2_mark_poisoned(file, "truncate"); + if (H5FDtruncate(file->inner, dxpl_id, closing) < 0) { + H5FD_poison_sec2_mark_poisoned(file, "truncate"); + return H5FD_poison_sec2_write_failure_result(); + } return 0; } @@ -562,4 +636,37 @@ herr_t H5FD_poison_sec2_set_callback( H5FD_poison_sec2_cb_g = cb; H5FD_poison_sec2_cb_ud_g = user_data; return 0; +} + +herr_t H5FD_poison_sec2_begin_fail_pass(void) { + H5FD_poison_sec2_clear_last_error(); + H5FD_poison_sec2_fail_pass_g = true; + return 0; +} + +herr_t H5FD_poison_sec2_end_fail_pass(void) { + H5FD_poison_sec2_fail_pass_g = false; + return 0; +} + +int H5FD_poison_sec2_get_last_error( + const char **filename, + const char **operation, + int *error_number +) { + if (filename == NULL || operation == NULL || error_number == NULL) + return -1; + + if (!H5FD_poison_sec2_last_error_g.valid) { + *filename = ""; + *operation = ""; + *error_number = 0; + return 0; + } + + *filename = H5FD_poison_sec2_last_error_g.filename; + *operation = H5FD_poison_sec2_last_error_g.operation; + *error_number = H5FD_poison_sec2_last_error_g.error_number; + + return 1; } \ No newline at end of file diff --git a/writer/H5FDpoison_sec2.h b/writer/H5FDpoison_sec2.h index edeb394d..d8d68636 100644 --- a/writer/H5FDpoison_sec2.h +++ b/writer/H5FDpoison_sec2.h @@ -7,21 +7,39 @@ extern "C" { #endif - typedef void (*H5FD_poison_sec2_cb_t)( - const char *filename, - const char *operation, - int error_number, - void *user_data - ); +typedef void (*H5FD_poison_sec2_cb_t)( + const char *filename, + const char *operation, + int error_number, + void *user_data +); - hid_t H5FD_poison_sec2_init(void); +hid_t H5FD_poison_sec2_init(void); - herr_t H5Pset_fapl_poison_sec2(hid_t fapl_id); +herr_t H5Pset_fapl_poison_sec2(hid_t fapl_id); - herr_t H5FD_poison_sec2_set_callback( - H5FD_poison_sec2_cb_t cb, - void *user_data - ); +herr_t H5FD_poison_sec2_set_callback( + H5FD_poison_sec2_cb_t cb, + void *user_data +); + +herr_t H5FD_poison_sec2_begin_fail_pass(void); +herr_t H5FD_poison_sec2_end_fail_pass(void); + +/* + * Returns: + * 1 if an error is available + * 0 if no error has been recorded since the last begin_fail_pass() + * -1 on invalid arguments + * + * filename and operation point to internal storage and remain valid until + * the next H5FD_poison_sec2_begin_fail_pass() or recorded VFD error. + */ +int H5FD_poison_sec2_get_last_error( + const char **filename, + const char **operation, + int *error_number +); #ifdef __cplusplus } diff --git a/writer/HDF5Objects.cpp b/writer/HDF5Objects.cpp index a6c49e1e..e596398e 100644 --- a/writer/HDF5Objects.cpp +++ b/writer/HDF5Objects.cpp @@ -766,32 +766,50 @@ void HDF5File::Close() { if (id < 0) return; - // Invalidate first; if anything below fails (e.g. ENOSPC) we must NOT - // leave a live id behind for the destructor or later code to touch. + // Invalidate first; if anything below fails we must NOT leave a live id + // behind for the destructor or later code to touch. const hid_t local_id = id; id = -1; - herr_t flush_err = 0; - H5E_BEGIN_TRY { - flush_err = H5Fflush(local_id, H5F_SCOPE_GLOBAL); - } H5E_END_TRY; + H5FD_poison_sec2_begin_fail_pass(); herr_t close_err = 0; H5E_BEGIN_TRY { close_err = H5Fclose(local_id); } H5E_END_TRY; - if (flush_err < 0 || close_err < 0) - throw JFJochException(JFJochExceptionCategory::HDF5, - "Failed to flush/close HDF5 file (likely no space left on device)"); + H5FD_poison_sec2_end_fail_pass(); + + const char *filename = nullptr; + const char *operation = nullptr; + int error_number = 0; + const int poison_error = H5FD_poison_sec2_get_last_error( + &filename, + &operation, + &error_number + ); + + if (close_err < 0 || poison_error > 0) + throw JFJochException( + JFJochExceptionCategory::HDF5, + "Failed to close HDF5 file, operation=" + + std::string(operation != nullptr ? operation : "") + + ", filename=" + + std::string(filename != nullptr ? filename : "") + + ", errno=" + + std::to_string(error_number) + ); } HDF5File::~HDF5File() { if (id >= 0) { - H5E_BEGIN_TRY { - H5Fclose(id); - } H5E_END_TRY; + const hid_t tmp = id; id = -1; + H5FD_poison_sec2_begin_fail_pass(); + H5E_BEGIN_TRY { + H5Fclose(tmp); + } H5E_END_TRY; + H5FD_poison_sec2_end_fail_pass(); } } -- 2.52.0 From 07c04c87789ba0d7ebb582007a42fdd1afd4b4ef Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 6 May 2026 11:28:15 +0200 Subject: [PATCH 21/28] HDF5: VFD handler reports error even if in fail-fast mode --- writer/H5FDpoison_sec2.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-) diff --git a/writer/H5FDpoison_sec2.c b/writer/H5FDpoison_sec2.c index e6120640..ac2a5e4c 100644 --- a/writer/H5FDpoison_sec2.c +++ b/writer/H5FDpoison_sec2.c @@ -88,11 +88,12 @@ static void H5FD_poison_sec2_store_last_error( ] = '\0'; } -static herr_t H5FD_poison_sec2_fail_fast(H5FD_poison_sec2_t *file) { +static herr_t H5FD_poison_sec2_fail_fast(H5FD_poison_sec2_t *file, const char *operation) { if (!file->poisoned) return 0; errno = file->poison_errno != 0 ? file->poison_errno : EIO; + H5FD_poison_sec2_store_last_error(file, operation, errno); return -1; } @@ -112,6 +113,8 @@ static herr_t H5FD_poison_sec2_mark_poisoned( H5FD_poison_sec2_cb_ud_g ); } + } else if (errno != 0) { + file->poison_errno = errno; } H5FD_poison_sec2_store_last_error(file, operation, file->poison_errno); @@ -306,7 +309,7 @@ static herr_t H5FD_poison_sec2_read( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "read") < 0) return -1; return H5FDread(file->inner, type, dxpl_id, addr, size, buf); @@ -325,7 +328,7 @@ static herr_t H5FD_poison_sec2_write( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "write") < 0) return H5FD_poison_sec2_write_failure_result(); if (H5FDwrite(file->inner, type, dxpl_id, addr, size, buf) < 0) { @@ -350,7 +353,7 @@ static herr_t H5FD_poison_sec2_read_vector( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "read_vector") < 0) return -1; return H5FDread_vector( @@ -378,7 +381,7 @@ static herr_t H5FD_poison_sec2_write_vector( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "write_vector") < 0) return H5FD_poison_sec2_write_failure_result(); if (H5FDwrite_vector( @@ -413,7 +416,7 @@ static herr_t H5FD_poison_sec2_read_selection( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "read_selection") < 0) return -1; return H5FDread_selection( @@ -445,7 +448,7 @@ static herr_t H5FD_poison_sec2_write_selection( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "write_selection") < 0) return H5FD_poison_sec2_write_failure_result(); if (H5FDwrite_selection( @@ -476,7 +479,7 @@ static herr_t H5FD_poison_sec2_flush( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "flush") < 0) return H5FD_poison_sec2_write_failure_result(); if (H5FDflush(file->inner, dxpl_id, closing) < 0) { @@ -497,7 +500,7 @@ static herr_t H5FD_poison_sec2_truncate( if (file->inner == NULL) return -1; - if (H5FD_poison_sec2_fail_fast(file) < 0) + if (H5FD_poison_sec2_fail_fast(file, "truncate") < 0) return H5FD_poison_sec2_write_failure_result(); if (H5FDtruncate(file->inner, dxpl_id, closing) < 0) { -- 2.52.0 From e5abee24bf63038f0bd178f85f8c811ab2d625a0 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 6 May 2026 11:29:37 +0200 Subject: [PATCH 22/28] Gitea: Debugging why enospc_shim.so is not being available to LD_PRELOAD --- .gitea/workflows/build_and_test.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index 50a9166b..e943243e 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -324,6 +324,8 @@ jobs: shell: bash run: | cd build/tests + ls -ltr *.so + ldd enospc_shim.so LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc - name: Run hdf5 test -- 2.52.0 From 28bb78fe65dee96f93dc609f25ab0d49ce4c6d22 Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 6 May 2026 11:37:23 +0200 Subject: [PATCH 23/28] HDF5: Update VFD license --- writer/H5FDpoison_sec2.c | 6 ++++++ writer/H5FDpoison_sec2.h | 6 ++++++ 2 files changed, 12 insertions(+) diff --git a/writer/H5FDpoison_sec2.c b/writer/H5FDpoison_sec2.c index ac2a5e4c..7dd99e45 100644 --- a/writer/H5FDpoison_sec2.c +++ b/writer/H5FDpoison_sec2.c @@ -1,3 +1,9 @@ +// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only OR HDF5 + +// This file may be used, modified, and distributed under either GPL-3.0-only +// or the HDF5 license, at the recipient's option. + #include "H5FDpoison_sec2.h" #include diff --git a/writer/H5FDpoison_sec2.h b/writer/H5FDpoison_sec2.h index d8d68636..5470080d 100644 --- a/writer/H5FDpoison_sec2.h +++ b/writer/H5FDpoison_sec2.h @@ -1,3 +1,9 @@ +// SPDX-FileCopyrightText: 2026 Filip Leonarski, Paul Scherrer Institute +// SPDX-License-Identifier: GPL-3.0-only OR HDF5 + +// This file may be used, modified, and distributed under either GPL-3.0-only +// or the HDF5 license, at the recipient's option. + #ifndef H5FD_POISON_SEC2_H #define H5FD_POISON_SEC2_H -- 2.52.0 From 97eb2c2c74a4f1cc22620cb79e99bbe0aa18a1fa Mon Sep 17 00:00:00 2001 From: leonarski_f Date: Wed, 6 May 2026 12:43:38 +0200 Subject: [PATCH 24/28] Gitea: ENOSPC test - try again --- .gitea/workflows/build_and_test.yml | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index e943243e..be1b7c42 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -315,19 +315,19 @@ jobs: cd build cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim - - name: Run unit tests - shell: bash - run: | - cd build/tests - ./jfjoch_test - name: ENOSPC test shell: bash run: | cd build/tests ls -ltr *.so ldd enospc_shim.so - LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc - LD_PRELOAD=enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc + LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc + LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc + - name: Run unit tests + shell: bash + run: | + cd build/tests + ./jfjoch_test - name: Run hdf5 test shell: bash run: | -- 2.52.0 From 001e76e7debc9bfe05def4e0503a58af44ea53a7 Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 6 May 2026 13:11:50 +0200 Subject: [PATCH 25/28] Gitea: Start longest test (unit tests) first. HDF5 ENOSPC test moved after standard test sequence. --- .gitea/workflows/build_and_test.yml | 72 ++++++++++++++--------------- 1 file changed, 35 insertions(+), 37 deletions(-) diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index be1b7c42..056ba51c 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -16,6 +16,41 @@ on: default: false jobs: + unit-tests: + name: Unit tests + runs-on: jfjoch_rocky8 + if: github.ref_type != 'tag' && github.ref_type != 'workflow_dispatch' + container: + image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2511 + options: --gpus all + timeout-minutes: 90 + env: + CTEST_OUTPUT_ON_FAILURE: '1' + steps: + - uses: actions/checkout@v4 + - name: Build tests + shell: bash + run: | + mkdir -p build + cd build + cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. + ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim + - name: Run unit tests + shell: bash + run: | + cd build/tests + ./jfjoch_test + - name: HDF5 ENOSPC test + shell: bash + run: | + cd build/tests + LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc + LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc + - name: Run hdf5 test + shell: bash + run: | + cd build/tools + ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 build-rpm: name: build:rpm (${{ matrix.distro }}) if: github.ref_type != 'workflow_dispatch' @@ -296,43 +331,6 @@ jobs: git add . git commit -m "Deploy site" git push -f https://${{secrets.GITHUB_TOKEN}}@gitea.psi.ch/${{ github.repository }}.git gitea-pages - unit-tests: - name: Unit tests - runs-on: jfjoch_rocky8 - if: github.ref_type != 'tag' && github.ref_type != 'workflow_dispatch' - container: - image: gitea.psi.ch/leonarski_f/jfjoch_rocky8:2511 - options: --gpus all - timeout-minutes: 90 - env: - CTEST_OUTPUT_ON_FAILURE: '1' - steps: - - uses: actions/checkout@v4 - - name: Build tests - shell: bash - run: | - mkdir -p build - cd build - cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. - ninja -j48 jfjoch_test jfjoch_hdf5_test jfjoch_hdf5_enospc_test enospc_shim - - name: ENOSPC test - shell: bash - run: | - cd build/tests - ls -ltr *.so - ldd enospc_shim.so - LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test HDF5File_enospc - LD_PRELOAD=./enospc_shim.so ./jfjoch_hdf5_enospc_test FileWriter_enospc - - name: Run unit tests - shell: bash - run: | - cd build/tests - ./jfjoch_test - - name: Run hdf5 test - shell: bash - run: | - cd build/tools - ./jfjoch_hdf5_test ../../tests/test_data/compression_benchmark.h5 create-release: name: Create release runs-on: jfjoch_rocky8 -- 2.52.0 From 9013443e3a2d89fde7b1a573c9b461fd596dfabb Mon Sep 17 00:00:00 2001 From: Filip Leonarski Date: Wed, 6 May 2026 13:16:33 +0200 Subject: [PATCH 26/28] VERSION: 1.0.0-rc.145 --- VERSION | 2 +- broker/gen/model/Azim_int_settings.cpp | 2 +- broker/gen/model/Azim_int_settings.h | 2 +- broker/gen/model/Broker_status.cpp | 2 +- broker/gen/model/Broker_status.h | 2 +- broker/gen/model/Calibration_statistics_inner.cpp | 2 +- broker/gen/model/Calibration_statistics_inner.h | 2 +- broker/gen/model/Dark_mask_settings.cpp | 2 +- broker/gen/model/Dark_mask_settings.h | 2 +- broker/gen/model/Dataset_settings.cpp | 2 +- broker/gen/model/Dataset_settings.h | 2 +- .../model/Dataset_settings_xray_fluorescence_spectrum.cpp | 2 +- .../model/Dataset_settings_xray_fluorescence_spectrum.h | 2 +- broker/gen/model/Detector.cpp | 2 +- broker/gen/model/Detector.h | 2 +- broker/gen/model/Detector_list.cpp | 2 +- broker/gen/model/Detector_list.h | 2 +- broker/gen/model/Detector_list_element.cpp | 2 +- broker/gen/model/Detector_list_element.h | 2 +- broker/gen/model/Detector_module.cpp | 2 +- broker/gen/model/Detector_module.h | 2 +- broker/gen/model/Detector_module_direction.cpp | 2 +- broker/gen/model/Detector_module_direction.h | 2 +- broker/gen/model/Detector_power_state.cpp | 2 +- broker/gen/model/Detector_power_state.h | 2 +- broker/gen/model/Detector_selection.cpp | 2 +- broker/gen/model/Detector_selection.h | 2 +- broker/gen/model/Detector_settings.cpp | 2 +- broker/gen/model/Detector_settings.h | 2 +- broker/gen/model/Detector_state.cpp | 2 +- broker/gen/model/Detector_state.h | 2 +- broker/gen/model/Detector_status.cpp | 2 +- broker/gen/model/Detector_status.h | 2 +- broker/gen/model/Detector_timing.cpp | 2 +- broker/gen/model/Detector_timing.h | 2 +- broker/gen/model/Detector_type.cpp | 2 +- broker/gen/model/Detector_type.h | 2 +- broker/gen/model/Error_message.cpp | 2 +- broker/gen/model/Error_message.h | 2 +- broker/gen/model/File_writer_format.cpp | 2 +- broker/gen/model/File_writer_format.h | 2 +- broker/gen/model/File_writer_settings.cpp | 2 +- broker/gen/model/File_writer_settings.h | 2 +- broker/gen/model/Fpga_status_inner.cpp | 2 +- broker/gen/model/Fpga_status_inner.h | 2 +- broker/gen/model/Geom_refinement_algorithm.cpp | 2 +- broker/gen/model/Geom_refinement_algorithm.h | 2 +- broker/gen/model/Grid_scan.cpp | 2 +- broker/gen/model/Grid_scan.h | 2 +- broker/gen/model/Helpers.cpp | 2 +- broker/gen/model/Helpers.h | 2 +- broker/gen/model/Image_buffer_status.cpp | 2 +- broker/gen/model/Image_buffer_status.h | 2 +- broker/gen/model/Image_format_settings.cpp | 2 +- broker/gen/model/Image_format_settings.h | 2 +- broker/gen/model/Image_pusher_status.cpp | 2 +- broker/gen/model/Image_pusher_status.h | 2 +- broker/gen/model/Image_pusher_type.cpp | 2 +- broker/gen/model/Image_pusher_type.h | 2 +- broker/gen/model/Indexing_algorithm.cpp | 2 +- broker/gen/model/Indexing_algorithm.h | 2 +- broker/gen/model/Indexing_settings.cpp | 2 +- broker/gen/model/Indexing_settings.h | 2 +- broker/gen/model/Instrument_metadata.cpp | 2 +- broker/gen/model/Instrument_metadata.h | 2 +- broker/gen/model/Jfjoch_settings.cpp | 2 +- broker/gen/model/Jfjoch_settings.h | 2 +- broker/gen/model/Jfjoch_statistics.cpp | 2 +- broker/gen/model/Jfjoch_statistics.h | 2 +- broker/gen/model/Measurement_statistics.cpp | 2 +- broker/gen/model/Measurement_statistics.h | 2 +- broker/gen/model/Pcie_devices_inner.cpp | 2 +- broker/gen/model/Pcie_devices_inner.h | 2 +- broker/gen/model/Pixel_mask_statistics.cpp | 2 +- broker/gen/model/Pixel_mask_statistics.h | 2 +- broker/gen/model/Plot.cpp | 2 +- broker/gen/model/Plot.h | 2 +- broker/gen/model/Plot_unit_x.cpp | 2 +- broker/gen/model/Plot_unit_x.h | 2 +- broker/gen/model/Plots.cpp | 2 +- broker/gen/model/Plots.h | 2 +- broker/gen/model/Roi_azim_list.cpp | 2 +- broker/gen/model/Roi_azim_list.h | 2 +- broker/gen/model/Roi_azimuthal.cpp | 2 +- broker/gen/model/Roi_azimuthal.h | 2 +- broker/gen/model/Roi_box.cpp | 2 +- broker/gen/model/Roi_box.h | 2 +- broker/gen/model/Roi_box_list.cpp | 2 +- broker/gen/model/Roi_box_list.h | 2 +- broker/gen/model/Roi_circle.cpp | 2 +- broker/gen/model/Roi_circle.h | 2 +- broker/gen/model/Roi_circle_list.cpp | 2 +- broker/gen/model/Roi_circle_list.h | 2 +- broker/gen/model/Roi_definitions.cpp | 2 +- broker/gen/model/Roi_definitions.h | 2 +- broker/gen/model/Rotation_axis.cpp | 2 +- broker/gen/model/Rotation_axis.h | 2 +- broker/gen/model/Scan_result.cpp | 2 +- broker/gen/model/Scan_result.h | 2 +- broker/gen/model/Scan_result_images_inner.cpp | 2 +- broker/gen/model/Scan_result_images_inner.h | 2 +- broker/gen/model/Spot_finding_settings.cpp | 2 +- broker/gen/model/Spot_finding_settings.h | 2 +- broker/gen/model/Standard_detector_geometry.cpp | 2 +- broker/gen/model/Standard_detector_geometry.h | 2 +- broker/gen/model/Tcp_settings.cpp | 2 +- broker/gen/model/Tcp_settings.h | 2 +- broker/gen/model/Unit_cell.cpp | 2 +- broker/gen/model/Unit_cell.h | 2 +- broker/gen/model/Zeromq_metadata_settings.cpp | 2 +- broker/gen/model/Zeromq_metadata_settings.h | 2 +- broker/gen/model/Zeromq_preview_settings.cpp | 2 +- broker/gen/model/Zeromq_preview_settings.h | 2 +- broker/gen/model/Zeromq_settings.cpp | 2 +- broker/gen/model/Zeromq_settings.h | 2 +- broker/jfjoch_api.yaml | 2 +- broker/redoc-static.html | 4 ++-- docs/CHANGELOG.md | 8 ++++++++ docs/conf.py | 2 +- docs/python_client/README.md | 4 ++-- fpga/hdl/action_config.v | 2 +- fpga/pcie_driver/dkms.conf | 2 +- fpga/pcie_driver/install_dkms.sh | 2 +- fpga/pcie_driver/jfjoch_drv.c | 2 +- fpga/pcie_driver/postinstall.sh | 2 +- fpga/pcie_driver/preuninstall.sh | 2 +- frontend/package-lock.json | 4 ++-- frontend/package.json | 2 +- frontend/src/openapi/core/OpenAPI.ts | 2 +- frontend/src/version.ts | 2 +- 130 files changed, 140 insertions(+), 132 deletions(-) diff --git a/VERSION b/VERSION index 4c76cce1..26294b6b 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0-rc.144 +1.0.0-rc.145 diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp index 8e3bfaf8..9c096ddc 100644 --- a/broker/gen/model/Azim_int_settings.cpp +++ b/broker/gen/model/Azim_int_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Azim_int_settings.h b/broker/gen/model/Azim_int_settings.h index 899941b7..d1dc546e 100644 --- a/broker/gen/model/Azim_int_settings.h +++ b/broker/gen/model/Azim_int_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.cpp b/broker/gen/model/Broker_status.cpp index 76a8c8d9..6af21437 100644 --- a/broker/gen/model/Broker_status.cpp +++ b/broker/gen/model/Broker_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Broker_status.h b/broker/gen/model/Broker_status.h index 922fcf81..a252389e 100644 --- a/broker/gen/model/Broker_status.h +++ b/broker/gen/model/Broker_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.cpp b/broker/gen/model/Calibration_statistics_inner.cpp index 3ec1cb2f..63cf5b16 100644 --- a/broker/gen/model/Calibration_statistics_inner.cpp +++ b/broker/gen/model/Calibration_statistics_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Calibration_statistics_inner.h b/broker/gen/model/Calibration_statistics_inner.h index 63d2d1af..6243d06c 100644 --- a/broker/gen/model/Calibration_statistics_inner.h +++ b/broker/gen/model/Calibration_statistics_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.cpp b/broker/gen/model/Dark_mask_settings.cpp index 7ade06a2..bc9d9e66 100644 --- a/broker/gen/model/Dark_mask_settings.cpp +++ b/broker/gen/model/Dark_mask_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dark_mask_settings.h b/broker/gen/model/Dark_mask_settings.h index 1de35154..432d90e1 100644 --- a/broker/gen/model/Dark_mask_settings.h +++ b/broker/gen/model/Dark_mask_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.cpp b/broker/gen/model/Dataset_settings.cpp index 9747cdd0..6007ae9d 100644 --- a/broker/gen/model/Dataset_settings.cpp +++ b/broker/gen/model/Dataset_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings.h b/broker/gen/model/Dataset_settings.h index 8d42009b..9fc61746 100644 --- a/broker/gen/model/Dataset_settings.h +++ b/broker/gen/model/Dataset_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp index 45c6d423..dc9e348d 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h index f724f92e..a57b93d8 100644 --- a/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h +++ b/broker/gen/model/Dataset_settings_xray_fluorescence_spectrum.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.cpp b/broker/gen/model/Detector.cpp index c1c3a401..d52df4bc 100644 --- a/broker/gen/model/Detector.cpp +++ b/broker/gen/model/Detector.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector.h b/broker/gen/model/Detector.h index 02901b8a..6fe6a9e3 100644 --- a/broker/gen/model/Detector.h +++ b/broker/gen/model/Detector.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.cpp b/broker/gen/model/Detector_list.cpp index d78041f3..6da3ffe3 100644 --- a/broker/gen/model/Detector_list.cpp +++ b/broker/gen/model/Detector_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list.h b/broker/gen/model/Detector_list.h index 68ad6e17..87acdeac 100644 --- a/broker/gen/model/Detector_list.h +++ b/broker/gen/model/Detector_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.cpp b/broker/gen/model/Detector_list_element.cpp index 758339a0..76e1e92e 100644 --- a/broker/gen/model/Detector_list_element.cpp +++ b/broker/gen/model/Detector_list_element.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_list_element.h b/broker/gen/model/Detector_list_element.h index 6751e4b5..8b3f642a 100644 --- a/broker/gen/model/Detector_list_element.h +++ b/broker/gen/model/Detector_list_element.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.cpp b/broker/gen/model/Detector_module.cpp index 09f2cf57..297e06c4 100644 --- a/broker/gen/model/Detector_module.cpp +++ b/broker/gen/model/Detector_module.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module.h b/broker/gen/model/Detector_module.h index b51b921c..e9b993eb 100644 --- a/broker/gen/model/Detector_module.h +++ b/broker/gen/model/Detector_module.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.cpp b/broker/gen/model/Detector_module_direction.cpp index e4e1dd58..55184bf0 100644 --- a/broker/gen/model/Detector_module_direction.cpp +++ b/broker/gen/model/Detector_module_direction.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_module_direction.h b/broker/gen/model/Detector_module_direction.h index bddfaccb..bee93b95 100644 --- a/broker/gen/model/Detector_module_direction.h +++ b/broker/gen/model/Detector_module_direction.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.cpp b/broker/gen/model/Detector_power_state.cpp index 17a6fe43..fe84a916 100644 --- a/broker/gen/model/Detector_power_state.cpp +++ b/broker/gen/model/Detector_power_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_power_state.h b/broker/gen/model/Detector_power_state.h index c1e85789..06d92476 100644 --- a/broker/gen/model/Detector_power_state.h +++ b/broker/gen/model/Detector_power_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.cpp b/broker/gen/model/Detector_selection.cpp index ef4de89c..8b5159fc 100644 --- a/broker/gen/model/Detector_selection.cpp +++ b/broker/gen/model/Detector_selection.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_selection.h b/broker/gen/model/Detector_selection.h index cd0defbb..2874f615 100644 --- a/broker/gen/model/Detector_selection.h +++ b/broker/gen/model/Detector_selection.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.cpp b/broker/gen/model/Detector_settings.cpp index 477c93ac..f9d25af7 100644 --- a/broker/gen/model/Detector_settings.cpp +++ b/broker/gen/model/Detector_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_settings.h b/broker/gen/model/Detector_settings.h index 0dcf3ac8..3af12b98 100644 --- a/broker/gen/model/Detector_settings.h +++ b/broker/gen/model/Detector_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.cpp b/broker/gen/model/Detector_state.cpp index 8545a15d..a0e37eeb 100644 --- a/broker/gen/model/Detector_state.cpp +++ b/broker/gen/model/Detector_state.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_state.h b/broker/gen/model/Detector_state.h index 42504328..a82a3f87 100644 --- a/broker/gen/model/Detector_state.h +++ b/broker/gen/model/Detector_state.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.cpp b/broker/gen/model/Detector_status.cpp index 49eec277..2e5a02c5 100644 --- a/broker/gen/model/Detector_status.cpp +++ b/broker/gen/model/Detector_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_status.h b/broker/gen/model/Detector_status.h index c7ba62e4..c458f496 100644 --- a/broker/gen/model/Detector_status.h +++ b/broker/gen/model/Detector_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.cpp b/broker/gen/model/Detector_timing.cpp index a0a70ce4..b649dfd7 100644 --- a/broker/gen/model/Detector_timing.cpp +++ b/broker/gen/model/Detector_timing.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_timing.h b/broker/gen/model/Detector_timing.h index 9cef3a1c..82ad066a 100644 --- a/broker/gen/model/Detector_timing.h +++ b/broker/gen/model/Detector_timing.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.cpp b/broker/gen/model/Detector_type.cpp index 20a08fad..31bb2580 100644 --- a/broker/gen/model/Detector_type.cpp +++ b/broker/gen/model/Detector_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Detector_type.h b/broker/gen/model/Detector_type.h index 2e74fceb..ca9808c8 100644 --- a/broker/gen/model/Detector_type.h +++ b/broker/gen/model/Detector_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.cpp b/broker/gen/model/Error_message.cpp index 8b6cfa67..a0f1997e 100644 --- a/broker/gen/model/Error_message.cpp +++ b/broker/gen/model/Error_message.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Error_message.h b/broker/gen/model/Error_message.h index 1e7a63e4..096fa33f 100644 --- a/broker/gen/model/Error_message.h +++ b/broker/gen/model/Error_message.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.cpp b/broker/gen/model/File_writer_format.cpp index 626155d2..644dd7da 100644 --- a/broker/gen/model/File_writer_format.cpp +++ b/broker/gen/model/File_writer_format.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_format.h b/broker/gen/model/File_writer_format.h index e836e65b..2c2c0a1e 100644 --- a/broker/gen/model/File_writer_format.h +++ b/broker/gen/model/File_writer_format.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.cpp b/broker/gen/model/File_writer_settings.cpp index 6430ba09..73016c29 100644 --- a/broker/gen/model/File_writer_settings.cpp +++ b/broker/gen/model/File_writer_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/File_writer_settings.h b/broker/gen/model/File_writer_settings.h index 503e51a2..fd5c38c3 100644 --- a/broker/gen/model/File_writer_settings.h +++ b/broker/gen/model/File_writer_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.cpp b/broker/gen/model/Fpga_status_inner.cpp index 7cd59759..078ef67b 100644 --- a/broker/gen/model/Fpga_status_inner.cpp +++ b/broker/gen/model/Fpga_status_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Fpga_status_inner.h b/broker/gen/model/Fpga_status_inner.h index f5aa99f9..cfd475fc 100644 --- a/broker/gen/model/Fpga_status_inner.h +++ b/broker/gen/model/Fpga_status_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.cpp b/broker/gen/model/Geom_refinement_algorithm.cpp index 5fa0660d..f2b9fd2d 100644 --- a/broker/gen/model/Geom_refinement_algorithm.cpp +++ b/broker/gen/model/Geom_refinement_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Geom_refinement_algorithm.h b/broker/gen/model/Geom_refinement_algorithm.h index 471d5c77..fc064a78 100644 --- a/broker/gen/model/Geom_refinement_algorithm.h +++ b/broker/gen/model/Geom_refinement_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.cpp b/broker/gen/model/Grid_scan.cpp index 9b6d2c0a..b6234130 100644 --- a/broker/gen/model/Grid_scan.cpp +++ b/broker/gen/model/Grid_scan.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Grid_scan.h b/broker/gen/model/Grid_scan.h index 12758168..8892afa1 100644 --- a/broker/gen/model/Grid_scan.h +++ b/broker/gen/model/Grid_scan.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.cpp b/broker/gen/model/Helpers.cpp index 08d1b524..18754e08 100644 --- a/broker/gen/model/Helpers.cpp +++ b/broker/gen/model/Helpers.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Helpers.h b/broker/gen/model/Helpers.h index 0a02e442..984ceb8e 100644 --- a/broker/gen/model/Helpers.h +++ b/broker/gen/model/Helpers.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.cpp b/broker/gen/model/Image_buffer_status.cpp index 4d698639..8b1e7e15 100644 --- a/broker/gen/model/Image_buffer_status.cpp +++ b/broker/gen/model/Image_buffer_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_buffer_status.h b/broker/gen/model/Image_buffer_status.h index c050e9a9..fd31782d 100644 --- a/broker/gen/model/Image_buffer_status.h +++ b/broker/gen/model/Image_buffer_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.cpp b/broker/gen/model/Image_format_settings.cpp index 775aa691..173cbade 100644 --- a/broker/gen/model/Image_format_settings.cpp +++ b/broker/gen/model/Image_format_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_format_settings.h b/broker/gen/model/Image_format_settings.h index a6b75288..db1f7e52 100644 --- a/broker/gen/model/Image_format_settings.h +++ b/broker/gen/model/Image_format_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.cpp b/broker/gen/model/Image_pusher_status.cpp index dce1d261..aedb2fab 100644 --- a/broker/gen/model/Image_pusher_status.cpp +++ b/broker/gen/model/Image_pusher_status.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_status.h b/broker/gen/model/Image_pusher_status.h index 6ae5bd49..64c265b6 100644 --- a/broker/gen/model/Image_pusher_status.h +++ b/broker/gen/model/Image_pusher_status.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.cpp b/broker/gen/model/Image_pusher_type.cpp index cd53f235..5cc2ad34 100644 --- a/broker/gen/model/Image_pusher_type.cpp +++ b/broker/gen/model/Image_pusher_type.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Image_pusher_type.h b/broker/gen/model/Image_pusher_type.h index 87d9678a..da47d740 100644 --- a/broker/gen/model/Image_pusher_type.h +++ b/broker/gen/model/Image_pusher_type.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.cpp b/broker/gen/model/Indexing_algorithm.cpp index bccb8149..0aae8f7a 100644 --- a/broker/gen/model/Indexing_algorithm.cpp +++ b/broker/gen/model/Indexing_algorithm.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_algorithm.h b/broker/gen/model/Indexing_algorithm.h index e6cc53e1..c262f653 100644 --- a/broker/gen/model/Indexing_algorithm.h +++ b/broker/gen/model/Indexing_algorithm.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.cpp b/broker/gen/model/Indexing_settings.cpp index a293f5a3..2e7fe958 100644 --- a/broker/gen/model/Indexing_settings.cpp +++ b/broker/gen/model/Indexing_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Indexing_settings.h b/broker/gen/model/Indexing_settings.h index b8b3aaae..980bc7f2 100644 --- a/broker/gen/model/Indexing_settings.h +++ b/broker/gen/model/Indexing_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.cpp b/broker/gen/model/Instrument_metadata.cpp index f2544113..e855d921 100644 --- a/broker/gen/model/Instrument_metadata.cpp +++ b/broker/gen/model/Instrument_metadata.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Instrument_metadata.h b/broker/gen/model/Instrument_metadata.h index 025786bb..e951e32f 100644 --- a/broker/gen/model/Instrument_metadata.h +++ b/broker/gen/model/Instrument_metadata.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.cpp b/broker/gen/model/Jfjoch_settings.cpp index 43d3a5dd..1f458f2c 100644 --- a/broker/gen/model/Jfjoch_settings.cpp +++ b/broker/gen/model/Jfjoch_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h index e7ac5c64..1b992d31 100644 --- a/broker/gen/model/Jfjoch_settings.h +++ b/broker/gen/model/Jfjoch_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.cpp b/broker/gen/model/Jfjoch_statistics.cpp index 478be99e..86559508 100644 --- a/broker/gen/model/Jfjoch_statistics.cpp +++ b/broker/gen/model/Jfjoch_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Jfjoch_statistics.h b/broker/gen/model/Jfjoch_statistics.h index f5c2c155..524a7fbd 100644 --- a/broker/gen/model/Jfjoch_statistics.h +++ b/broker/gen/model/Jfjoch_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.cpp b/broker/gen/model/Measurement_statistics.cpp index 63c70e16..3f4eaf95 100644 --- a/broker/gen/model/Measurement_statistics.cpp +++ b/broker/gen/model/Measurement_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Measurement_statistics.h b/broker/gen/model/Measurement_statistics.h index 25cf8b90..f7ac1a7a 100644 --- a/broker/gen/model/Measurement_statistics.h +++ b/broker/gen/model/Measurement_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.cpp b/broker/gen/model/Pcie_devices_inner.cpp index 5dc3ad27..bcfa7dc3 100644 --- a/broker/gen/model/Pcie_devices_inner.cpp +++ b/broker/gen/model/Pcie_devices_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pcie_devices_inner.h b/broker/gen/model/Pcie_devices_inner.h index 7df703b2..eb7c1b98 100644 --- a/broker/gen/model/Pcie_devices_inner.h +++ b/broker/gen/model/Pcie_devices_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.cpp b/broker/gen/model/Pixel_mask_statistics.cpp index 082417e7..4e4dbad8 100644 --- a/broker/gen/model/Pixel_mask_statistics.cpp +++ b/broker/gen/model/Pixel_mask_statistics.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Pixel_mask_statistics.h b/broker/gen/model/Pixel_mask_statistics.h index 44e0cd4a..0d7f2285 100644 --- a/broker/gen/model/Pixel_mask_statistics.h +++ b/broker/gen/model/Pixel_mask_statistics.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.cpp b/broker/gen/model/Plot.cpp index 17f9c547..11d3bb27 100644 --- a/broker/gen/model/Plot.cpp +++ b/broker/gen/model/Plot.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot.h b/broker/gen/model/Plot.h index b7949505..82dea397 100644 --- a/broker/gen/model/Plot.h +++ b/broker/gen/model/Plot.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.cpp b/broker/gen/model/Plot_unit_x.cpp index 5e1bc7b1..40786bee 100644 --- a/broker/gen/model/Plot_unit_x.cpp +++ b/broker/gen/model/Plot_unit_x.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plot_unit_x.h b/broker/gen/model/Plot_unit_x.h index 9c59a0d4..e421e47f 100644 --- a/broker/gen/model/Plot_unit_x.h +++ b/broker/gen/model/Plot_unit_x.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.cpp b/broker/gen/model/Plots.cpp index 4c71e785..d17c38bd 100644 --- a/broker/gen/model/Plots.cpp +++ b/broker/gen/model/Plots.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Plots.h b/broker/gen/model/Plots.h index eef909e3..59e73b63 100644 --- a/broker/gen/model/Plots.h +++ b/broker/gen/model/Plots.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.cpp b/broker/gen/model/Roi_azim_list.cpp index e3006623..7cf0dcdc 100644 --- a/broker/gen/model/Roi_azim_list.cpp +++ b/broker/gen/model/Roi_azim_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azim_list.h b/broker/gen/model/Roi_azim_list.h index c808f43d..7bc7dc90 100644 --- a/broker/gen/model/Roi_azim_list.h +++ b/broker/gen/model/Roi_azim_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.cpp b/broker/gen/model/Roi_azimuthal.cpp index 8a7e6bd6..d6222b39 100644 --- a/broker/gen/model/Roi_azimuthal.cpp +++ b/broker/gen/model/Roi_azimuthal.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_azimuthal.h b/broker/gen/model/Roi_azimuthal.h index 7ac2cbae..28b621d5 100644 --- a/broker/gen/model/Roi_azimuthal.h +++ b/broker/gen/model/Roi_azimuthal.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.cpp b/broker/gen/model/Roi_box.cpp index 1a296fff..b16dc8a1 100644 --- a/broker/gen/model/Roi_box.cpp +++ b/broker/gen/model/Roi_box.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box.h b/broker/gen/model/Roi_box.h index 404ae691..d32a04f2 100644 --- a/broker/gen/model/Roi_box.h +++ b/broker/gen/model/Roi_box.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.cpp b/broker/gen/model/Roi_box_list.cpp index e62061a7..33b779a9 100644 --- a/broker/gen/model/Roi_box_list.cpp +++ b/broker/gen/model/Roi_box_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_box_list.h b/broker/gen/model/Roi_box_list.h index 9e420e5e..911531ed 100644 --- a/broker/gen/model/Roi_box_list.h +++ b/broker/gen/model/Roi_box_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.cpp b/broker/gen/model/Roi_circle.cpp index d674cf61..030e54a5 100644 --- a/broker/gen/model/Roi_circle.cpp +++ b/broker/gen/model/Roi_circle.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle.h b/broker/gen/model/Roi_circle.h index 1432d60b..3565ec61 100644 --- a/broker/gen/model/Roi_circle.h +++ b/broker/gen/model/Roi_circle.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.cpp b/broker/gen/model/Roi_circle_list.cpp index 3431e5af..ccac8cfb 100644 --- a/broker/gen/model/Roi_circle_list.cpp +++ b/broker/gen/model/Roi_circle_list.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_circle_list.h b/broker/gen/model/Roi_circle_list.h index 46c38a30..bfd711c0 100644 --- a/broker/gen/model/Roi_circle_list.h +++ b/broker/gen/model/Roi_circle_list.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.cpp b/broker/gen/model/Roi_definitions.cpp index fe14c448..e26b21b0 100644 --- a/broker/gen/model/Roi_definitions.cpp +++ b/broker/gen/model/Roi_definitions.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Roi_definitions.h b/broker/gen/model/Roi_definitions.h index 1dc95532..4324bb09 100644 --- a/broker/gen/model/Roi_definitions.h +++ b/broker/gen/model/Roi_definitions.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.cpp b/broker/gen/model/Rotation_axis.cpp index 9159d63c..bd2a52d5 100644 --- a/broker/gen/model/Rotation_axis.cpp +++ b/broker/gen/model/Rotation_axis.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Rotation_axis.h b/broker/gen/model/Rotation_axis.h index 566f3289..0eb6414c 100644 --- a/broker/gen/model/Rotation_axis.h +++ b/broker/gen/model/Rotation_axis.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.cpp b/broker/gen/model/Scan_result.cpp index a1a75ff9..1ec871dc 100644 --- a/broker/gen/model/Scan_result.cpp +++ b/broker/gen/model/Scan_result.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result.h b/broker/gen/model/Scan_result.h index 725774fe..bb42ae0f 100644 --- a/broker/gen/model/Scan_result.h +++ b/broker/gen/model/Scan_result.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.cpp b/broker/gen/model/Scan_result_images_inner.cpp index fdca9fa9..378515fa 100644 --- a/broker/gen/model/Scan_result_images_inner.cpp +++ b/broker/gen/model/Scan_result_images_inner.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Scan_result_images_inner.h b/broker/gen/model/Scan_result_images_inner.h index ab4b3a5a..d69781a5 100644 --- a/broker/gen/model/Scan_result_images_inner.h +++ b/broker/gen/model/Scan_result_images_inner.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.cpp b/broker/gen/model/Spot_finding_settings.cpp index 9f399793..fe9c0ebc 100644 --- a/broker/gen/model/Spot_finding_settings.cpp +++ b/broker/gen/model/Spot_finding_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Spot_finding_settings.h b/broker/gen/model/Spot_finding_settings.h index b7ddd995..b9e5c2e8 100644 --- a/broker/gen/model/Spot_finding_settings.h +++ b/broker/gen/model/Spot_finding_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.cpp b/broker/gen/model/Standard_detector_geometry.cpp index 92aa04d6..29610aa5 100644 --- a/broker/gen/model/Standard_detector_geometry.cpp +++ b/broker/gen/model/Standard_detector_geometry.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Standard_detector_geometry.h b/broker/gen/model/Standard_detector_geometry.h index 7d652656..48923ab0 100644 --- a/broker/gen/model/Standard_detector_geometry.h +++ b/broker/gen/model/Standard_detector_geometry.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.cpp b/broker/gen/model/Tcp_settings.cpp index 86c36f29..d3f34952 100644 --- a/broker/gen/model/Tcp_settings.cpp +++ b/broker/gen/model/Tcp_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Tcp_settings.h b/broker/gen/model/Tcp_settings.h index 71d4a141..5737af1a 100644 --- a/broker/gen/model/Tcp_settings.h +++ b/broker/gen/model/Tcp_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.cpp b/broker/gen/model/Unit_cell.cpp index 14c08ae4..97aebf45 100644 --- a/broker/gen/model/Unit_cell.cpp +++ b/broker/gen/model/Unit_cell.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Unit_cell.h b/broker/gen/model/Unit_cell.h index 585f4562..7313b5da 100644 --- a/broker/gen/model/Unit_cell.h +++ b/broker/gen/model/Unit_cell.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.cpp b/broker/gen/model/Zeromq_metadata_settings.cpp index a667208a..6ec1baf7 100644 --- a/broker/gen/model/Zeromq_metadata_settings.cpp +++ b/broker/gen/model/Zeromq_metadata_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_metadata_settings.h b/broker/gen/model/Zeromq_metadata_settings.h index 02e7221c..0b1a27ad 100644 --- a/broker/gen/model/Zeromq_metadata_settings.h +++ b/broker/gen/model/Zeromq_metadata_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.cpp b/broker/gen/model/Zeromq_preview_settings.cpp index 8dedb6cf..ef8dc85b 100644 --- a/broker/gen/model/Zeromq_preview_settings.cpp +++ b/broker/gen/model/Zeromq_preview_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_preview_settings.h b/broker/gen/model/Zeromq_preview_settings.h index 999d22eb..71115d32 100644 --- a/broker/gen/model/Zeromq_preview_settings.h +++ b/broker/gen/model/Zeromq_preview_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.cpp b/broker/gen/model/Zeromq_settings.cpp index 97d4b7c3..47aa13ab 100644 --- a/broker/gen/model/Zeromq_settings.cpp +++ b/broker/gen/model/Zeromq_settings.cpp @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/gen/model/Zeromq_settings.h b/broker/gen/model/Zeromq_settings.h index 40bb8907..96d921d9 100644 --- a/broker/gen/model/Zeromq_settings.h +++ b/broker/gen/model/Zeromq_settings.h @@ -2,7 +2,7 @@ * Jungfraujoch * API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates. # License Clarification While this API definition is licensed under GPL-3.0, **the GPL copyleft provisions do not apply** when this file is used solely to generate OpenAPI clients or when implementing applications that interact with the API. Generated client code and applications using this API definition are not subject to the GPL license requirements and may be distributed under terms of your choosing. This exception is similar in spirit to the Linux Kernel's approach to userspace API headers and the GCC Runtime Library Exception. The Linux Kernel developers have explicitly stated that user programs that merely use the kernel interfaces (syscalls, ioctl definitions, etc.) are not derivative works of the kernel and are not subject to the terms of the GPL. This exception is intended to allow wider use of this API specification without imposing GPL requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. * -* The version of the OpenAPI document: 1.0.0-rc.144 +* The version of the OpenAPI document: 1.0.0-rc.145 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). diff --git a/broker/jfjoch_api.yaml b/broker/jfjoch_api.yaml index bc4c3134..2908599e 100644 --- a/broker/jfjoch_api.yaml +++ b/broker/jfjoch_api.yaml @@ -22,7 +22,7 @@ info: requirements on applications that merely interact with the API, regardless of whether they communicate through network calls or other mechanisms. - version: 1.0.0-rc.144 + version: 1.0.0-rc.145 contact: name: Filip Leonarski (Paul Scherrer Institute) email: filip.leonarski@psi.ch diff --git a/broker/redoc-static.html b/broker/redoc-static.html index c492e4e5..94fae561 100644 --- a/broker/redoc-static.html +++ b/broker/redoc-static.html @@ -399,7 +399,7 @@ This format doesn't transmit information about X-axis, only values, so it i 55.627 l 55.6165,55.627 -231.245496,231.24803 c -127.185,127.1864 -231.5279,231.248 -231.873,231.248 -0.3451,0 -104.688, -104.0616 -231.873,-231.248 z - " fill="currentColor">

Jungfraujoch (1.0.0-rc.144)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). + " fill="currentColor">

Jungfraujoch (1.0.0-rc.145)

Download OpenAPI specification:

Filip Leonarski (Paul Scherrer Institute): filip.leonarski@psi.ch License: GPL-3.0

API to control Jungfraujoch developed by the Paul Scherrer Institute (Switzerland). Jungfraujoch is a data acquisition and analysis system for pixel array detectors, primarly PSI JUNGFRAU. Jungfraujoch uses FPGA boards to acquire data at high data rates.

License Clarification

While this API definition is licensed under GPL-3.0, the GPL copyleft provisions do not apply @@ -932,7 +932,7 @@ then image might be replaced in the buffer between calling /images and /image.cb