diff --git a/.gitea/workflows/build_and_test.yml b/.gitea/workflows/build_and_test.yml index 12c9e272..a28d95f2 100644 --- a/.gitea/workflows/build_and_test.yml +++ b/.gitea/workflows/build_and_test.yml @@ -76,6 +76,21 @@ jobs: upload_url: https://gitea.psi.ch/api/packages/mx/debian/pool/noble/nocuda/upload steps: - uses: actions/checkout@v4 + - name: Install CMake 3.26 on Ubuntu 22.04 + if: matrix.distro == 'ubuntu2204' || matrix.distro == 'ubuntu2204_nocuda' + shell: bash + run: | + set -euo pipefail + apt-get update + apt-get install -y wget gpg ca-certificates + wget -qO- https://apt.kitware.com/keys/kitware-archive-latest.asc \ + | gpg --dearmor \ + | tee /usr/share/keyrings/kitware-archive-keyring.gpg > /dev/null + echo "deb [signed-by=/usr/share/keyrings/kitware-archive-keyring.gpg] https://apt.kitware.com/ubuntu/ jammy main" \ + | tee /etc/apt/sources.list.d/kitware.list > /dev/null + apt-get update + apt-get install -y cmake=3.26.* cmake-data=3.26.* kitware-archive-keyring + cmake --version - name: Build packages shell: bash run: | diff --git a/CMakeLists.txt b/CMakeLists.txt index c0441e2d..fe260198 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,4 +1,4 @@ -CMAKE_MINIMUM_REQUIRED(VERSION 3.19) +CMAKE_MINIMUM_REQUIRED(VERSION 3.26) FILE(STRINGS VERSION JFJOCH_VERSION) @@ -87,10 +87,19 @@ SET(HDF5_BUILD_CPP_LIB OFF) SET(HDF5_ENABLE_Z_LIB_SUPPORT ON) SET(HDF5_EXTERNALLY_CONFIGURED 1) +SET(SPDLOG_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) +SET(SPDLOG_BUILD_TESTS OFF CACHE BOOL "" FORCE) +SET(SPDLOG_BUILD_BENCH OFF CACHE BOOL "" FORCE) +set(SPDLOG_BUILD_SHARED OFF CACHE BOOL "" FORCE) +SET(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE) + +SET(HTTPLIB_USE_NON_BLOCKING_GETADDRINFO OFF CACHE BOOL "" FORCE) +SET(HTTPLIB_REQUIRE_ZLIB ON CACHE BOOL "" FORCE) + FetchContent_Declare( - pistache_http - GIT_REPOSITORY https://github.com/fleon-psi/pistache - GIT_TAG 0393f6c + spdlog + GIT_REPOSITORY https://github.com/gabime/spdlog.git + GIT_TAG v1.17.0 EXCLUDE_FROM_ALL ) @@ -104,7 +113,7 @@ FetchContent_Declare( FetchContent_Declare(hdf5 GIT_REPOSITORY https://github.com/HDFGroup/hdf5/ - GIT_TAG hdf5_1.14.6 + GIT_TAG hdf5_2.1.0 GIT_SHALLOW 1 EXCLUDE_FROM_ALL) @@ -117,16 +126,24 @@ FetchContent_Declare( sls_detector_package GIT_REPOSITORY https://github.com/slsdetectorgroup/slsDetectorPackage GIT_TAG ${SLS_DETECTOR_GIT_TAG} + EXCLUDE_FROM_ALL ) FetchContent_Declare( catch2 GIT_REPOSITORY https://github.com/catchorg/Catch2 - GIT_TAG 4e8d92b + GIT_TAG v3.13.0 EXCLUDE_FROM_ALL ) -FetchContent_MakeAvailable(pistache_http zstd sls_detector_package catch2 hdf5) +FetchContent_Declare( + httplib + GIT_REPOSITORY https://github.com/yhirose/cpp-httplib.git + GIT_TAG v0.39.0 + EXCLUDE_FROM_ALL +) + +FetchContent_MakeAvailable(zstd sls_detector_package catch2 hdf5 spdlog httplib) ADD_SUBDIRECTORY(jungfrau) ADD_SUBDIRECTORY(compression) diff --git a/VERSION b/VERSION index 4d890636..91f33f63 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.0-rc.132 \ No newline at end of file +1.0.0-rc.133 \ No newline at end of file diff --git a/broker/CMakeLists.txt b/broker/CMakeLists.txt index fe51bf6a..8a87b41a 100644 --- a/broker/CMakeLists.txt +++ b/broker/CMakeLists.txt @@ -15,8 +15,8 @@ ADD_LIBRARY(JFJochBroker STATIC TARGET_LINK_LIBRARIES(JFJochBroker JFJochReceiver JFJochDetector JFJochCommon JFJochAPI JFJochPreview) -ADD_EXECUTABLE(jfjoch_broker jfjoch_broker.cpp JFJochBrokerHttp.cpp JFJochBrokerHttp.h - gen/api/DefaultApi.cpp gen/api/DefaultApi.h gen/api/ApiBase.h gen/api/ApiBase.cpp) -TARGET_LINK_LIBRARIES(jfjoch_broker JFJochBroker pistache_static ${CMAKE_DL_LIBS}) +ADD_EXECUTABLE(jfjoch_broker jfjoch_broker.cpp JFJochBrokerHttp.cpp JFJochBrokerHttp.h) + +TARGET_LINK_LIBRARIES(jfjoch_broker JFJochBroker httplib::httplib ${CMAKE_DL_LIBS}) TARGET_INCLUDE_DIRECTORIES(jfjoch_broker PUBLIC gen/api) INSTALL(TARGETS jfjoch_broker RUNTIME COMPONENT jfjoch) diff --git a/broker/JFJochBrokerHttp.cpp b/broker/JFJochBrokerHttp.cpp index 459e630f..dd5c48d1 100644 --- a/broker/JFJochBrokerHttp.cpp +++ b/broker/JFJochBrokerHttp.cpp @@ -2,24 +2,92 @@ // SPDX-License-Identifier: GPL-3.0-only // Using OpenAPI licensed with Apache License 2.0 -#include #include "JFJochBrokerHttp.h" -#include "gen/model/Error_message.h" + +#include +#include +#include +#include + +#include "Helpers.h" #include "../common/GitInfo.h" -#include "OpenAPIConvert.h" #include "../preview/JFJochTIFF.h" +#include "OpenAPIConvert.h" +#include "gen/model/Error_message.h" + +using namespace org::openapitools::server::model; + +namespace { + template + bool fromStringValue(const std::string &s, T &out) { + std::istringstream is(s); + is >> out; + return !is.fail() && is.eof(); + } + + template<> + bool fromStringValue(const std::string &s, std::string &out) { + out = s; + return true; + } + + template<> + bool fromStringValue(const std::string &s, bool &out) { + if (s == "true" || s == "1") { + out = true; + return true; + } + if (s == "false" || s == "0") { + out = false; + return true; + } + return false; + } + + template + std::optional parse_query_value(const httplib::Request &req, const char *name) { + if (!req.has_param(name)) + return std::nullopt; + T v{}; + if (fromStringValue(req.get_param_value(name), v)) + return v; + return std::nullopt; + } + + std::optional parse_query_string(const httplib::Request &req, const char *name) { + if (!req.has_param(name)) + return std::nullopt; + return req.get_param_value(name); + } + + std::string mime_from_path(const std::string &path) { + if (path.ends_with(".js")) return "text/javascript"; + if (path.ends_with(".css")) return "text/css"; + if (path.ends_with(".html")) return "text/html"; + if (path.ends_with(".json")) return "application/json"; + if (path.ends_with(".cbor")) return "application/cbor"; + if (path.ends_with(".jpeg") || path.ends_with(".jpg")) return "image/jpeg"; + if (path.ends_with(".tiff") || path.ends_with(".tif")) return "image/tiff"; + if (path.ends_with(".png")) return "image/png"; + if (path.ends_with(".svg")) return "image/svg+xml"; + if (path.ends_with(".bin")) return "application/octet-stream"; + return "application/octet-stream"; + } + + inline bool read_file_to_string(const std::string &path, std::string &out) { + std::ifstream f(path, std::ios::binary); + if (!f) + return false; + std::ostringstream ss; + ss << f.rdbuf(); + out = ss.str(); + return true; + } +} JFJochBrokerHttp::JFJochBrokerHttp(const DiffractionExperiment &experiment, - const SpotFindingSettings& spot_finding_settings, - std::shared_ptr &rtr) - : DefaultApi(rtr), - state_machine(experiment, services, logger, spot_finding_settings) { - Pistache::Rest::Routes::Get(*rtr, "/", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this)); - Pistache::Rest::Routes::Get(*rtr, "/frontend", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this)); - Pistache::Rest::Routes::Get(*rtr, "/frontend/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this)); - Pistache::Rest::Routes::Get(*rtr, "/frontend/assets/*", Pistache::Rest::Routes::bind(&JFJochBrokerHttp::GetStaticFile, this)); - - init(); + const SpotFindingSettings &spot_finding_settings) + : state_machine(experiment, services, logger, spot_finding_settings) { } void JFJochBrokerHttp::AddDetectorSetup(const DetectorSetup &setup) { @@ -31,42 +99,291 @@ JFJochServices &JFJochBrokerHttp::Services() { return services; } -void JFJochBrokerHttp::cancel_post(Pistache::Http::ResponseWriter &response) { +JFJochBrokerHttp &JFJochBrokerHttp::FrontendDirectory(const std::string &directory) { + frontend_directory = directory; + return *this; +} + +std::pair JFJochBrokerHttp::handleParsingException(const std::exception &ex) const noexcept { + try { + throw; + } catch (const nlohmann::detail::exception &e) { + return {400, e.what()}; + } catch (const org::openapitools::server::helpers::ValidationException &e) { + return {400, e.what()}; + } catch (const std::exception &e) { + return {500, e.what()}; + } +} + +std::pair JFJochBrokerHttp::handleOperationException(const std::exception &ex) const noexcept { + try { + throw; + } catch (const WrongDAQStateException &) { + Error_message msg; + msg.setMsg(ex.what()); + msg.setReason("WrongDAQState"); + nlohmann::json j; + to_json(j, msg); + return {500, j.dump()}; + } catch (const std::exception &) { + Error_message msg; + msg.setMsg(ex.what()); + msg.setReason("Other"); + nlohmann::json j; + to_json(j, msg); + return {500, j.dump()}; + } +} + +void JFJochBrokerHttp::attach(httplib::Server &server) { + register_routes(server); + server.set_error_handler([](const httplib::Request &, httplib::Response &res) { + res.status = 404; + res.set_content("The requested method does not exist", "text/plain"); + }); +} + +void JFJochBrokerHttp::register_routes(httplib::Server &server) { + auto bind_noarg = [this](auto method) { + return [this, method](const httplib::Request &, httplib::Response &res) { + try { + (this->*method)(res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }; + }; + + auto bind_json = [this](auto method, auto model_tag) { + return [this, method](const httplib::Request &req, httplib::Response &res) { + using Model = decltype(model_tag); + try { + Model v; + nlohmann::json::parse(req.body).get_to(v); + v.validate(); + (this->*method)(v, res); + } catch (const std::exception &e) { + auto [c, s] = handleParsingException(e); + send_plain(res, c, s); + } + }; + }; + + auto bind_req = [this](auto method) { + return [this, method](const httplib::Request &req, httplib::Response &res) { + try { + (this->*method)(req, res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }; + }; + + server.Post("/cancel", bind_noarg(&JFJochBrokerHttp::cancel_post)); + server.Get("/config/azim_int", bind_noarg(&JFJochBrokerHttp::config_azim_int_get)); + server.Put("/config/azim_int", bind_json(&JFJochBrokerHttp::config_azim_int_put, Azim_int_settings{})); + server.Get("/config/dark_mask", bind_noarg(&JFJochBrokerHttp::config_dark_mask_get)); + server.Put("/config/dark_mask", bind_json(&JFJochBrokerHttp::config_dark_mask_put, Dark_mask_settings{})); + server.Get("/config/detector", bind_noarg(&JFJochBrokerHttp::config_detector_get)); + server.Put("/config/detector", bind_json(&JFJochBrokerHttp::config_detector_put, Detector_settings{})); + server.Get("/config/file_writer", bind_noarg(&JFJochBrokerHttp::config_file_writer_get)); + server.Put("/config/file_writer", bind_json(&JFJochBrokerHttp::config_file_writer_put, File_writer_settings{})); + server.Post("/config/image_format/conversion", bind_noarg(&JFJochBrokerHttp::config_image_format_conversion_post)); + server.Get("/config/image_format", bind_noarg(&JFJochBrokerHttp::config_image_format_get)); + server.Put("/config/image_format", bind_json(&JFJochBrokerHttp::config_image_format_put, Image_format_settings{})); + server.Post("/config/image_format/raw", bind_noarg(&JFJochBrokerHttp::config_image_format_raw_post)); + server.Get("/config/indexing", bind_noarg(&JFJochBrokerHttp::config_indexing_get)); + server.Put("/config/indexing", bind_json(&JFJochBrokerHttp::config_indexing_put, Indexing_settings{})); + server.Get("/config/instrument", bind_noarg(&JFJochBrokerHttp::config_instrument_get)); + server.Put("/config/instrument", bind_json(&JFJochBrokerHttp::config_instrument_put, Instrument_metadata{})); + server.Put("/config/internal_generator_image", [this](const httplib::Request &req, httplib::Response &res) { + try { + config_internal_generator_image_put(parse_query_value(req, "id"), req, res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + server.Put("/config/internal_generator_image.tiff", [this](const httplib::Request &req, httplib::Response &res) { + try { + config_internal_generator_image_tiff_put(parse_query_value(req, "id"), req, res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + server.Get("/config/mask", bind_noarg(&JFJochBrokerHttp::config_mask_get)); + server.Get("/config/mask.tiff", bind_noarg(&JFJochBrokerHttp::config_mask_tiff_get)); + server.Get("/config/roi", bind_noarg(&JFJochBrokerHttp::config_roi_get)); + server.Put("/config/roi", bind_json(&JFJochBrokerHttp::config_roi_put, Roi_definitions{})); + server.Get("/config/select_detector", bind_noarg(&JFJochBrokerHttp::config_select_detector_get)); + server.Put("/config/select_detector", + bind_json(&JFJochBrokerHttp::config_select_detector_put, Detector_selection{})); + server.Get("/config/spot_finding", bind_noarg(&JFJochBrokerHttp::config_spot_finding_get)); + server.Put("/config/spot_finding", bind_json(&JFJochBrokerHttp::config_spot_finding_put, Spot_finding_settings{})); + server.Get("/config/user_mask", bind_noarg(&JFJochBrokerHttp::config_user_mask_get)); + server.Put("/config/user_mask", bind_req(&JFJochBrokerHttp::config_user_mask_put)); + server.Get("/config/user_mask.tiff", bind_noarg(&JFJochBrokerHttp::config_user_mask_tiff_get)); + server.Put("/config/user_mask.tiff", bind_req(&JFJochBrokerHttp::config_user_mask_tiff_put)); + server.Get("/config/zeromq_metadata", bind_noarg(&JFJochBrokerHttp::config_zeromq_metadata_get)); + server.Put("/config/zeromq_metadata", + bind_json(&JFJochBrokerHttp::config_zeromq_metadata_put, Zeromq_metadata_settings{})); + server.Get("/config/zeromq_preview", bind_noarg(&JFJochBrokerHttp::config_zeromq_preview_get)); + server.Put("/config/zeromq_preview", + bind_json(&JFJochBrokerHttp::config_zeromq_preview_put, Zeromq_preview_settings{})); + server.Post("/deactivate", bind_noarg(&JFJochBrokerHttp::deactivate_post)); + server.Get("/detector/status", bind_noarg(&JFJochBrokerHttp::detector_status_get)); + server.Get("/fpga_status", bind_noarg(&JFJochBrokerHttp::fpga_status_get)); + server.Post("/image_buffer/clear", bind_noarg(&JFJochBrokerHttp::image_buffer_clear_post)); + + server.Get("/image_buffer/image.cbor", [this](const httplib::Request &req, httplib::Response &res) { + try { + image_buffer_image_cbor_get(parse_query_value(req, "id"), res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/image_buffer/image.jpeg", [this](const httplib::Request &req, httplib::Response &res) { + try { + image_buffer_image_jpeg_get( + parse_query_value(req, "id"), + parse_query_value(req, "show_user_mask"), + parse_query_value(req, "show_roi"), + parse_query_value(req, "show_spots"), + parse_query_value(req, "show_beam_center"), + parse_query_value(req, "saturation"), + parse_query_value(req, "jpeg_quality"), + parse_query_value(req, "show_res_ring"), + parse_query_string(req, "color"), + parse_query_value(req, "show_res_est"), + res + ); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/image_buffer/image.tiff", [this](const httplib::Request &req, httplib::Response &res) { + try { + image_buffer_image_tiff_get(parse_query_value(req, "id"), res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/image_buffer/start.cbor", bind_noarg(&JFJochBrokerHttp::image_buffer_start_cbor_get)); + server.Get("/image_buffer/status", bind_noarg(&JFJochBrokerHttp::image_buffer_status_get)); + server.Get("/image_pusher/status", bind_noarg(&JFJochBrokerHttp::image_pusher_status_get)); + server.Post("/initialize", bind_noarg(&JFJochBrokerHttp::initialize_post)); + server.Post("/pedestal", bind_noarg(&JFJochBrokerHttp::pedestal_post)); + + server.Get("/preview/pedestal.tiff", [this](const httplib::Request &req, httplib::Response &res) { + try { + preview_pedestal_tiff_get(parse_query_value(req, "gain_level"), + parse_query_value(req, "sc"), + res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/preview/plot.bin", [this](const httplib::Request &req, httplib::Response &res) { + try { + preview_plot_bin_get(parse_query_string(req, "type"), + parse_query_string(req, "roi"), + res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/preview/plot", [this](const httplib::Request &req, httplib::Response &res) { + try { + preview_plot_get(parse_query_string(req, "type"), + parse_query_value(req, "binning"), + parse_query_value(req, "fill"), + parse_query_value(req, "experimental_coord"), + parse_query_string(req, "azint_unit"), + res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/result/scan", bind_noarg(&JFJochBrokerHttp::result_scan_get)); + server.Post("/start", bind_json(&JFJochBrokerHttp::start_post, Dataset_settings{})); + server.Get("/statistics/calibration", bind_noarg(&JFJochBrokerHttp::statistics_calibration_get)); + server.Get("/statistics/data_collection", bind_noarg(&JFJochBrokerHttp::statistics_data_collection_get)); + + server.Get("/statistics", [this](const httplib::Request &req, httplib::Response &res) { + try { + statistics_get(res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/status", bind_noarg(&JFJochBrokerHttp::status_get)); + server.Post("/trigger", bind_noarg(&JFJochBrokerHttp::trigger_post)); + server.Get("/version", bind_noarg(&JFJochBrokerHttp::version_get)); + + server.Post("/wait_till_done", [this](const httplib::Request &req, httplib::Response &res) { + try { + wait_till_done_post(parse_query_value(req, "timeout"), res); + } catch (const std::exception &e) { + auto [c, s] = handleOperationException(e); + send_plain(res, c, s); + } + }); + + server.Get("/xfel/event_code", bind_noarg(&JFJochBrokerHttp::xfel_event_code_get)); + server.Get("/xfel/pulse_id", bind_noarg(&JFJochBrokerHttp::xfel_pulse_id_get)); +} + +void JFJochBrokerHttp::cancel_post(httplib::Response &response) { state_machine.Cancel(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::deactivate_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::deactivate_post(httplib::Response &response) { state_machine.Deactivate(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::initialize_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::initialize_post(httplib::Response &response) { state_machine.Initialize(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::start_post(const Dataset_settings &datasetSettings, httplib::Response &response) { nlohmann::json j = datasetSettings; logger.Info("Start {}", j.dump()); state_machine.Start(Convert(datasetSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::status_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::status_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetStatus()), response); } - - -void JFJochBrokerHttp::wait_till_done_post(const std::optional &timeout, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::wait_till_done_post(const std::optional &timeout, httplib::Response &response) { BrokerStatus status; if (!timeout) status = state_machine.WaitTillMeasurementDone(std::chrono::minutes(1)); else if ((timeout.value() > 3600) || (timeout.value() < 0)) { - response.send(Pistache::Http::Code::Bad_Request); + response.status = 400; + response.set_content("timeout must be in range 0..3600", "text/plain"); return; } else if (timeout.value() == 0) status = state_machine.GetStatus(); @@ -75,321 +392,128 @@ void JFJochBrokerHttp::wait_till_done_post(const std::optional &timeout switch (status.state) { case JFJochState::Idle: - response.send(Pistache::Http::Code::Ok); + response.status = 200; break; case JFJochState::Inactive: - response.send(Pistache::Http::Code::Bad_Gateway); + response.status = 502; break; case JFJochState::Error: throw WrongDAQStateException(status.message.value_or("Unknown error")); case JFJochState::Measuring: case JFJochState::Busy: case JFJochState::Calibration: - response.send(Pistache::Http::Code::Gateway_Timeout); + response.status = 504; break; } } -void JFJochBrokerHttp::trigger_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::trigger_post(httplib::Response &response) { state_machine.Trigger(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::pedestal_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::pedestal_post(httplib::Response &response) { state_machine.Pedestal(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_detector_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_detector_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetDetectorSettings()), response); } -void JFJochBrokerHttp::config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_detector_put(const Detector_settings &detectorSettings, + httplib::Response &response) { state_machine.LoadDetectorSettings(Convert(detectorSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_azim_int_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_azim_int_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetRadialIntegrationSettings()), response); } -void JFJochBrokerHttp::config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &radIntSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_azim_int_put(const Azim_int_settings &radIntSettings, + httplib::Response &response) { state_machine.SetRadialIntegrationSettings(Convert(radIntSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_select_detector_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_select_detector_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetDetectorsList()), response); } -void JFJochBrokerHttp::config_select_detector_put( - const org::openapitools::server::model::Detector_selection &detectorSelection, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_select_detector_put(const Detector_selection &detectorSelection, + httplib::Response &response) { state_machine.SelectDetector(detectorSelection.getId()); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_spot_finding_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_spot_finding_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetSpotFindingSettings()), response); } -void JFJochBrokerHttp::config_spot_finding_put( - const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_spot_finding_put(const Spot_finding_settings &spotFindingSettings, + httplib::Response &response) { state_machine.SetSpotFindingSettings(Convert(spotFindingSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::statistics_calibration_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::statistics_calibration_get(httplib::Response &response) { nlohmann::json j; for (const auto &d: Convert(state_machine.GetCalibrationStatistics())) j.push_back(d); - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); + logger.Info("Calibration statistics: {}", j.dump()); + response.set_content(j.dump(), "application/json"); + response.status = 200; } -void JFJochBrokerHttp::statistics_data_collection_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::statistics_data_collection_get(httplib::Response &response) { auto stats = state_machine.GetMeasurementStatistics(); - if (stats) { + if (stats) ProcessOutput(Convert(stats.value()), response); - } else { - response.send(Pistache::Http::Code::Not_Found); - } -} - -std::pair -JFJochBrokerHttp::handleOperationException(const std::exception &ex) const noexcept { - try { - throw; - } catch (const WrongDAQStateException &e) { - org::openapitools::server::model::Error_message msg; - msg.setMsg(ex.what()); - msg.setReason("WrongDAQState"); - nlohmann::json j; - to_json(j, msg); - return std::make_pair(Pistache::Http::Code::Internal_Server_Error, j.dump()); - } catch (const std::exception &e) { - org::openapitools::server::model::Error_message msg; - msg.setMsg(ex.what()); - msg.setReason("Other"); - nlohmann::json j; - to_json(j, msg); - return std::make_pair(Pistache::Http::Code::Internal_Server_Error, j.dump()); - } -} - -void JFJochBrokerHttp::GetStaticFile(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response) { - if (!frontend_directory.empty()) { - logger.Info("Requesting static resource {} from {}", request.resource(), frontend_directory); - if (request.resource().find("../") != std::string::npos) - response.send(Pistache::Http::Code::Forbidden); - try { - if ((request.resource() == "/") - || (request.resource() == "/frontend") - || (request.resource() == "/frontend/")) - Pistache::Http::serveFile(response, frontend_directory + "/index.html", MIME(Text, Html)); - else if (request.resource().starts_with("/frontend/")) { - if (request.resource().ends_with(".js")) - Pistache::Http::serveFile(response, frontend_directory + "/" + request.resource().substr(10), - MIME(Text,Javascript)); - else if (request.resource().ends_with(".css")) - Pistache::Http::serveFile(response, frontend_directory + "/" + request.resource().substr(10), - MIME(Text,Css)); - else if (request.resource().ends_with(".html")) - Pistache::Http::serveFile(response, frontend_directory + "/" + request.resource().substr(10), - MIME(Text,Html)); - else - Pistache::Http::serveFile(response, frontend_directory + "/" + request.resource().substr(10)); - - } - else response.send(Pistache::Http::Code::Not_Found); - } catch (const std::exception &e) { - logger.Error(e.what()); - response.send(Pistache::Http::Code::Not_Found); - } - } else response.send(Pistache::Http::Code::Not_Found); -} - -JFJochBrokerHttp &JFJochBrokerHttp::FrontendDirectory(const std::string &directory) { - frontend_directory = directory; - return *this; -} - -void JFJochBrokerHttp::detector_status_get(Pistache::Http::ResponseWriter &response) { - auto out = state_machine.GetDetectorStatus(); - if (out) - ProcessOutput(Convert(out.value()), response); else - response.send(Pistache::Http::Code::Not_Found); + response.status = 404; } - -void JFJochBrokerHttp::config_internal_generator_image_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) { - int64_t image_number = 0; - auto number_query = request.query().get("id"); - if (number_query) - image_number = std::stoi(number_query.value()); - - if ((image_number < 0) || (image_number > 127)) - throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "id must be in range 0-127"); - - state_machine.LoadInternalGeneratorImage(request.body().data(), request.body().size(), image_number); - logger.Info("Internal generator image #{} loaded", image_number); - response.send(Pistache::Http::Code::Ok); +void JFJochBrokerHttp::config_file_writer_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetFileWriterSettings()), response); } - -void JFJochBrokerHttp::config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) { - int64_t image_number = 0; - auto number_query = request.query().get("id"); - if (number_query) - image_number = std::stoi(number_query.value()); - - if ((image_number < 0) || (image_number > 127)) - throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, "id must be in range 0-127"); - - state_machine.LoadInternalGeneratorImageTIFF(request.body(), image_number); - response.send(Pistache::Http::Code::Ok); +void JFJochBrokerHttp::config_file_writer_put(const File_writer_settings &fileWriterSettings, + httplib::Response &response) { + state_machine.LoadFileWriterSettings(Convert(fileWriterSettings)); + response.status = 200; } -void JFJochBrokerHttp::config_roi_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetROIDefintion()), response); -} - -void JFJochBrokerHttp::config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions, - -Pistache::Http::ResponseWriter &response) { - state_machine.SetROIDefinition(Convert(roiDefinitions)); - response.send(Pistache::Http::Code::Ok); -} - -void JFJochBrokerHttp::xfel_event_code_get(Pistache::Http::ResponseWriter &response) { - auto array = state_machine.GetXFELEventCode(); - if (array.empty()) - response.send(Pistache::Http::Code::Not_Found); - nlohmann::json j = array; - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); -} - -void JFJochBrokerHttp::xfel_pulse_id_get(Pistache::Http::ResponseWriter &response) { - auto array = state_machine.GetXFELPulseID(); - if (array.empty()) - response.send(Pistache::Http::Code::Not_Found); - nlohmann::json j = array; - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); -} - -void JFJochBrokerHttp::preview_pedestal_tiff_get(const std::optional &gainLevel, - const std::optional &sc, - Pistache::Http::ResponseWriter &response) { - if (!gainLevel) - response.send(Pistache::Http::Code::Bad_Request); - std::string s = state_machine.GetPedestalTIFF(gainLevel.value(), sc ? sc.value() : 0); - if (!s.empty()) - response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff")); - else - response.send(Pistache::Http::Code::Not_Found); -} - -void JFJochBrokerHttp::config_mask_tiff_get(Pistache::Http::ResponseWriter &response) { - auto s = state_machine.GetFullPixelMaskTIFF(); - response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff")); -} - -void JFJochBrokerHttp::config_user_mask_tiff_get(Pistache::Http::ResponseWriter &response) { - auto s = state_machine.GetUserPixelMaskTIFF(); - response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff")); -} - -void JFJochBrokerHttp::config_user_mask_tiff_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) { - uint32_t cols, lines; - auto v = ReadTIFFFromString32(request.body(), cols, lines); - state_machine.SetUserPixelMask(v); - response.send(Pistache::Http::Code::Ok); -} - -void JFJochBrokerHttp::config_mask_get(Pistache::Http::ResponseWriter &response) { - const auto v = state_machine.GetFullPixelMask(); - response.send(Pistache::Http::Code::Ok, - reinterpret_cast(v.data()), - v.size() * sizeof(uint32_t), - Pistache::Http::Mime::MediaType::fromString("application/octet-stream")); -} - -void JFJochBrokerHttp::config_user_mask_get(Pistache::Http::ResponseWriter &response) { - const auto v = state_machine.GetUserPixelMask(); - response.send(Pistache::Http::Code::Ok, - reinterpret_cast(v.data()), - v.size() * sizeof(uint32_t), - Pistache::Http::Mime::MediaType::fromString("application/octet-stream")); -} - -void JFJochBrokerHttp::config_user_mask_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) { - if (request.body().empty()) { - response.send(Pistache::Http::Code::Bad_Request, "Request body cannot be empty"); - return; - } - - if (request.body().size() % 4 != 0) { - response.send(Pistache::Http::Code::Bad_Request, "Request has to be 32-bit"); - return; - } - - std::vector v(request.body().size() / 4); - memcpy(v.data(), request.body().data(), request.body().size()); - state_machine.SetUserPixelMask(v); - response.send(Pistache::Http::Code::Ok); -} - -void JFJochBrokerHttp::version_get(Pistache::Http::ResponseWriter &response) { - response.send(Pistache::Http::Code::Ok, jfjoch_version(), MIME(Text, Plain)); -} - -void JFJochBrokerHttp::config_instrument_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetInstrumentMetadata()), response); -} - -void JFJochBrokerHttp::config_instrument_put(const org::openapitools::server::model::Instrument_metadata - &instrumentMetadata,Pistache::Http::ResponseWriter &response) { - state_machine.LoadInstrumentMetadata(Convert(instrumentMetadata)); - response.send(Pistache::Http::Code::Ok); -} - -void JFJochBrokerHttp::config_image_format_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_image_format_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetImageFormatSettings()), response); } -void JFJochBrokerHttp::config_image_format_put( - const org::openapitools::server::model::Image_format_settings &imageFormatSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_image_format_put(const Image_format_settings &imageFormatSettings, + httplib::Response &response) { state_machine.LoadImageFormatSettings(Convert(imageFormatSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_image_format_conversion_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_image_format_conversion_post(httplib::Response &response) { state_machine.ConvImageFormatSettings(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_image_format_raw_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_image_format_raw_post(httplib::Response &response) { state_machine.RawImageFormatSettings(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::fpga_status_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::fpga_status_get(httplib::Response &response) { nlohmann::json j; for (const auto &d: Convert(state_machine.GetDeviceStatus())) j.push_back(d); - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); + response.set_content(j.dump(), "application/json"); + response.status = 200; } -void JFJochBrokerHttp::statistics_get(const std::optional &compression, Pistache::Http::ResponseWriter &response) { - org::openapitools::server::model::Jfjoch_statistics statistics; +void JFJochBrokerHttp::statistics_get(httplib::Response &response) { + Jfjoch_statistics statistics; auto data_collection_statistics = state_machine.GetMeasurementStatistics(); if (data_collection_statistics) @@ -426,50 +550,77 @@ void JFJochBrokerHttp::statistics_get(const std::optional &compression, Pi statistics.setZeromqMetadata(Convert(zeromq_metadata)); nlohmann::json j = statistics; - if (!compression.has_value() || compression.value()) - response.setCompression(Pistache::Http::Header::Encoding::Deflate); - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); + response.set_content(j.dump(), "application/json"); + response.status = 200; } -void JFJochBrokerHttp::config_zeromq_preview_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_zeromq_preview_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetPreviewSocketSettings()), response); } -void JFJochBrokerHttp::config_zeromq_preview_put( - const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_zeromq_preview_put(const Zeromq_preview_settings &zeromqPreviewSettings, + httplib::Response &response) { state_machine.SetPreviewSocketSettings(Convert(zeromqPreviewSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::config_zeromq_metadata_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_zeromq_metadata_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetMetadataSocketSettings()), response); } -void JFJochBrokerHttp::config_zeromq_metadata_put( - const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings, - Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_zeromq_metadata_put(const Zeromq_metadata_settings &zeromqMetadataSettings, + httplib::Response &response) { state_machine.SetMetadataSocketSettings(Convert(zeromqMetadataSettings)); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } -void JFJochBrokerHttp::image_buffer_clear_post(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::config_internal_generator_image_put(const std::optional &id, + const httplib::Request &request, + httplib::Response &response) { + int64_t image_number = id.value_or(0); + + if ((image_number < 0) || (image_number > 127)) { + response.status = 400; + response.set_content("id must be in range 0-127", "text/plain"); + return; + } + + state_machine.LoadInternalGeneratorImage(request.body.data(), request.body.size(), image_number); + logger.Info("Internal generator image #{} loaded", image_number); + response.status = 200; +} + +void JFJochBrokerHttp::config_internal_generator_image_tiff_put(const std::optional &id, + const httplib::Request &request, + httplib::Response &response) { + int64_t image_number = id.value_or(0); + + if ((image_number < 0) || (image_number > 127)) { + response.status = 400; + response.set_content("id must be in range 0-127", "text/plain"); + return; + } + + state_machine.LoadInternalGeneratorImageTIFF(request.body, image_number); + response.status = 200; +} + +void JFJochBrokerHttp::image_buffer_clear_post(httplib::Response &response) { state_machine.ClearImageBuffer(); - response.send(Pistache::Http::Code::Ok); + response.status = 200; } void JFJochBrokerHttp::image_buffer_image_cbor_get(const std::optional &imageNumber, - Pistache::Http::ResponseWriter &response) { + httplib::Response &response) { std::vector tmp_vector; state_machine.GetImageFromBuffer(tmp_vector, imageNumber.value_or(-1)); - std::string s = std::string((char *) tmp_vector.data(), tmp_vector.size()); + std::string s(reinterpret_cast(tmp_vector.data()), tmp_vector.size()); if (!s.empty()) - response.send(Pistache::Http::Code::Ok, s, - Pistache::Http::Mime::MediaType::fromString("application/cbor")); + response.set_content(s, "application/cbor"); else - response.send(Pistache::Http::Code::Not_Found); + response.status = 404; } void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional &id, @@ -482,76 +633,209 @@ void JFJochBrokerHttp::image_buffer_image_jpeg_get(const std::optional const std::optional &showResRing, const std::optional &color, const std::optional &showResEst, - Pistache::Http::ResponseWriter &response) { + httplib::Response &response) { int64_t image_id = id.value_or(ImageBuffer::MaxImage); PreviewImageSettings settings{}; - settings.show_user_mask = showUserMask.value_or(true); + settings.show_user_mask = showUserMask.value_or(false); settings.show_roi = showRoi.value_or(false); settings.show_spots = showSpots.value_or(true); settings.saturation_value = saturation; settings.background_value = 0.0; settings.jpeg_quality = jpegQuality.value_or(100); - if (showResEst.value_or(false)) + if (showResEst.value_or(false)) { settings.show_res_est = true; - else { + } else { settings.show_res_est = false; settings.resolution_ring = showResRing; } settings.scale = ConvertColorScale(color); settings.show_beam_center = showBeamCenter.value_or(true); settings.format = PreviewImageFormat::JPEG; + std::string s = state_machine.GetPreviewJPEG(settings, image_id); if (!s.empty()) - response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/jpeg")); + response.set_content(s, "image/jpeg"); else - response.send(Pistache::Http::Code::Not_Found); + response.status = 404; } -void -JFJochBrokerHttp::image_buffer_image_tiff_get(const std::optional &id, Pistache::Http::ResponseWriter &response) { - int64_t image_id = ImageBuffer::MaxImage; - if (id.has_value()) - image_id = id.value(); +void JFJochBrokerHttp::image_buffer_image_tiff_get(const std::optional &id, + httplib::Response &response) { + int64_t image_id = id.value_or(ImageBuffer::MaxImage); std::string s = state_machine.GetPreviewTIFF(image_id); if (!s.empty()) - response.send(Pistache::Http::Code::Ok, s, Pistache::Http::Mime::MediaType::fromString("image/tiff")); + response.set_content(s, "image/tiff"); else - response.send(Pistache::Http::Code::Not_Found); + response.status = 404; } -void JFJochBrokerHttp::image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::image_buffer_start_cbor_get(httplib::Response &response) { std::vector tmp_vector; state_machine.GetStartMessageFromBuffer(tmp_vector); - std::string s = std::string((char *) tmp_vector.data(), tmp_vector.size()); + std::string s(reinterpret_cast(tmp_vector.data()), tmp_vector.size()); if (!s.empty()) - response.send(Pistache::Http::Code::Ok, s, - Pistache::Http::Mime::MediaType::fromString("application/cbor")); + response.set_content(s, "application/cbor"); else - response.send(Pistache::Http::Code::Not_Found); + response.status = 404; } -void JFJochBrokerHttp::image_buffer_status_get(Pistache::Http::ResponseWriter &response) { +void JFJochBrokerHttp::image_buffer_status_get(httplib::Response &response) { ProcessOutput(Convert(state_machine.GetImageBufferStatus()), response); } -void JFJochBrokerHttp::config_file_writer_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetFileWriterSettings()), response); +void JFJochBrokerHttp::image_pusher_status_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetImagePusherStatus()), response); } -void JFJochBrokerHttp::config_file_writer_put( - const org::openapitools::server::model::File_writer_settings &fileWriterSettings, - Pistache::Http::ResponseWriter &response) { - state_machine.LoadFileWriterSettings(Convert(fileWriterSettings)); - response.send(Pistache::Http::Code::Ok); +void JFJochBrokerHttp::config_mask_tiff_get(httplib::Response &response) { + auto s = state_machine.GetFullPixelMaskTIFF(); + response.set_content(s, "image/tiff"); + response.status = 200; } -void JFJochBrokerHttp::preview_plot_get(const std::optional &type, const std::optional &binning, - const std::optional &compression, const std::optional &fill, +void JFJochBrokerHttp::config_user_mask_tiff_get(httplib::Response &response) { + auto s = state_machine.GetUserPixelMaskTIFF(); + response.set_content(s, "image/tiff"); + response.status = 200; +} + +void JFJochBrokerHttp::config_user_mask_tiff_put(const httplib::Request &request, + httplib::Response &response) { + uint32_t cols, lines; + auto v = ReadTIFFFromString32(request.body, cols, lines); + state_machine.SetUserPixelMask(v); + response.status = 200; +} + +void JFJochBrokerHttp::config_mask_get(httplib::Response &response) { + const auto v = state_machine.GetFullPixelMask(); + response.set_content(reinterpret_cast(v.data()), + v.size() * sizeof(uint32_t), + "application/octet-stream"); + response.status = 200; +} + +void JFJochBrokerHttp::config_user_mask_get(httplib::Response &response) { + const auto v = state_machine.GetUserPixelMask(); + response.set_content(reinterpret_cast(v.data()), + v.size() * sizeof(uint32_t), + "application/octet-stream"); + response.status = 200; +} + +void JFJochBrokerHttp::config_user_mask_put(const httplib::Request &request, + httplib::Response &response) { + if (request.body.empty()) { + response.status = 400; + response.set_content("Request body cannot be empty", "text/plain"); + return; + } + + if (request.body.size() % 4 != 0) { + response.status = 400; + response.set_content("Request has to be 32-bit", "text/plain"); + return; + } + + std::vector v(request.body.size() / 4); + std::memcpy(v.data(), request.body.data(), request.body.size()); + state_machine.SetUserPixelMask(v); + response.status = 200; +} + +void JFJochBrokerHttp::version_get(httplib::Response &response) { + response.set_content(jfjoch_version(), "text/plain"); + response.status = 200; +} + +void JFJochBrokerHttp::config_instrument_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetInstrumentMetadata()), response); +} + +void JFJochBrokerHttp::config_instrument_put(const Instrument_metadata &instrumentMetadata, + httplib::Response &response) { + state_machine.LoadInstrumentMetadata(Convert(instrumentMetadata)); + response.status = 200; +} + +void JFJochBrokerHttp::config_indexing_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetIndexingSettings()), response); +} + +void JFJochBrokerHttp::config_indexing_put(const Indexing_settings &indexingSettings, + httplib::Response &response) { + state_machine.SetIndexingSettings(Convert(indexingSettings)); + response.status = 200; +} + +void JFJochBrokerHttp::result_scan_get(httplib::Response &response) { + auto ret = state_machine.GetScanResult(); + if (ret.has_value()) + ProcessOutput(Convert(ret.value()), response); + else + response.status = 404; +} + +void JFJochBrokerHttp::config_dark_mask_put(const Dark_mask_settings &darkMaskSettings, + httplib::Response &response) { + state_machine.SetDarkMaskSettings(Convert(darkMaskSettings)); + response.status = 200; +} + +void JFJochBrokerHttp::config_dark_mask_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetDarkMaskSettings()), response); +} + +void JFJochBrokerHttp::detector_status_get(httplib::Response &response) { + auto out = state_machine.GetDetectorStatus(); + if (out) + ProcessOutput(Convert(out.value()), response); + else + response.status = 404; +} + +void JFJochBrokerHttp::preview_pedestal_tiff_get(const std::optional &gainLevel, + const std::optional &sc, + httplib::Response &response) { + if (!gainLevel) { + response.status = 400; + response.set_content("gain_level is required", "text/plain"); + return; + } + + std::string s = state_machine.GetPedestalTIFF(gainLevel.value(), sc ? sc.value() : 0); + if (!s.empty()) + response.set_content(s, "image/tiff"); + else + response.status = 404; +} + +void JFJochBrokerHttp::preview_plot_bin_get(const std::optional &type, + const std::optional &roi, + httplib::Response &response) { + std::vector ret; + state_machine.GetPlotRaw(ret, ConvertPlotType(type), roi.value_or("")); + + if (ret.empty()) { + response.status = 404; + return; + } + + response.set_content(reinterpret_cast(ret.data()), + ret.size() * sizeof(float), + "application/octet-stream"); + response.status = 200; +} + +void JFJochBrokerHttp::preview_plot_get(const std::optional &type, + const std::optional &binning, + const std::optional &fill, const std::optional &experimentalCoord, - const std::optional &azintUnit, Pistache::Http::ResponseWriter &response) { + const std::optional &azintUnit, + httplib::Response &response) { PlotAzintUnit unit = PlotAzintUnit::Q_recipA; if (azintUnit.has_value()) { if (azintUnit == "Q_recipA" || azintUnit == "q_recipa") @@ -571,57 +855,45 @@ void JFJochBrokerHttp::preview_plot_get(const std::optional &type, }; if (binning) { - if (binning.value() < 0) - throw JFJochException(JFJochExceptionCategory::InputParameterInvalid, - "Binning must be positive number or zero"); + if (binning.value() < 0) { + response.status = 400; + response.set_content("Binning cannot be negative", "text/plain"); + return; + } req.binning = binning.value(); } auto plot = state_machine.GetPlots(req); - ProcessOutput(Convert(plot), response, compression.value_or(false)); + ProcessOutput(Convert(plot), response); } -void JFJochBrokerHttp::preview_plot_bin_get(const std::optional &type, - const std::optional &roi, - Pistache::Http::ResponseWriter &response) { - std::vector ret; - state_machine.GetPlotRaw(ret, ConvertPlotType(type), roi.value_or("")); - - if (ret.empty()) - response.send(Pistache::Http::Code::Ok); - else - response.send(Pistache::Http::Code::Ok, - reinterpret_cast(ret.data()), - ret.size() * sizeof(float), - Pistache::Http::Mime::MediaType::fromString("application/octet-stream")); +void JFJochBrokerHttp::config_roi_get(httplib::Response &response) { + ProcessOutput(Convert(state_machine.GetROIDefintion()), response); } -void JFJochBrokerHttp::config_indexing_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetIndexingSettings()), response); +void JFJochBrokerHttp::config_roi_put(const Roi_definitions &roiDefinitions, + httplib::Response &response) { + state_machine.SetROIDefinition(Convert(roiDefinitions)); + response.status = 200; } -void JFJochBrokerHttp::config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings, - Pistache::Http::ResponseWriter &response) { - state_machine.SetIndexingSettings(Convert(indexingSettings)); - response.send(Pistache::Http::Code::Ok); +void JFJochBrokerHttp::xfel_event_code_get(httplib::Response &response) { + auto array = state_machine.GetXFELEventCode(); + if (array.empty()) { + response.status = 404; + return; + } + nlohmann::json j = array; + response.set_content(j.dump(), "application/json"); + response.status = 200; } -void JFJochBrokerHttp::result_scan_get(Pistache::Http::ResponseWriter &response) { - auto ret = state_machine.GetScanResult(); - if (ret.has_value()) - ProcessOutput(Convert(ret.value()), response, true); - else - response.send(Pistache::Http::Code::Not_Found); -} - -void JFJochBrokerHttp::config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, Pistache::Http::ResponseWriter &response) { - state_machine.SetDarkMaskSettings(Convert(darkMaskSettings)); - response.send(Pistache::Http::Code::Ok); -} - -void JFJochBrokerHttp::config_dark_mask_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetDarkMaskSettings()), response); -} - -void JFJochBrokerHttp::image_pusher_status_get(Pistache::Http::ResponseWriter &response) { - ProcessOutput(Convert(state_machine.GetImagePusherStatus()), response); +void JFJochBrokerHttp::xfel_pulse_id_get(httplib::Response &response) { + auto array = state_machine.GetXFELPulseID(); + if (array.empty()) { + response.status = 404; + return; + } + nlohmann::json j = array; + response.set_content(j.dump(), "application/json"); + response.status = 200; } diff --git a/broker/JFJochBrokerHttp.h b/broker/JFJochBrokerHttp.h index d68b7e96..3cfe134e 100644 --- a/broker/JFJochBrokerHttp.h +++ b/broker/JFJochBrokerHttp.h @@ -1,208 +1,195 @@ // SPDX-FileCopyrightText: 2024 Filip Leonarski, Paul Scherrer Institute // SPDX-License-Identifier: GPL-3.0-only // Using OpenAPI licensed with Apache License 2.0 +#pragma once -#ifndef JUNGFRAUJOCH_JFJOCHBROKERHTTP_H -#define JUNGFRAUJOCH_JFJOCHBROKERHTTP_H +#include +#include -#include -#include -#include -#include +#include +#include +#include +#include #include "../common/Logger.h" +#include "JFJochServices.h" #include "JFJochStateMachine.h" -#include "gen/api/DefaultApi.h" +#include "OpenAPIConvert.h" +#include "gen/model/Azim_int_settings.h" +#include "gen/model/Broker_status.h" +#include "gen/model/Dark_mask_settings.h" +#include "gen/model/Dataset_settings.h" +#include "gen/model/Detector_selection.h" +#include "gen/model/Detector_settings.h" +#include "gen/model/Detector_status.h" +#include "gen/model/Error_message.h" +#include "gen/model/File_writer_settings.h" +#include "gen/model/Image_buffer_status.h" +#include "gen/model/Image_format_settings.h" +#include "gen/model/Image_pusher_status.h" +#include "gen/model/Indexing_settings.h" +#include "gen/model/Instrument_metadata.h" +#include "gen/model/Jfjoch_statistics.h" +#include "gen/model/Plots.h" +#include "gen/model/Roi_definitions.h" +#include "gen/model/Scan_result.h" +#include "gen/model/Spot_finding_settings.h" +#include "gen/model/Zeromq_metadata_settings.h" +#include "gen/model/Zeromq_preview_settings.h" -class JFJochBrokerHttp : public org::openapitools::server::api::DefaultApi { +class JFJochBrokerHttp { Logger logger{"JFJochBroker"}; - JFJochServices services {logger}; - - void config_image_format_get(Pistache::Http::ResponseWriter &response) override; - - void config_image_format_put(const org::openapitools::server::model::Image_format_settings &imageFormatSettings, - Pistache::Http::ResponseWriter &response) override; - - void fpga_status_get(Pistache::Http::ResponseWriter &response) override; - + JFJochServices services{logger}; JFJochStateMachine state_machine; std::string frontend_directory; - void config_detector_get(Pistache::Http::ResponseWriter &response) override; - - void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings, - Pistache::Http::ResponseWriter &response) override; - - void config_azim_int_get(Pistache::Http::ResponseWriter &response) override; - - void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &radIntSettings, - Pistache::Http::ResponseWriter &response) override; - - void config_select_detector_get(Pistache::Http::ResponseWriter &response) override; - - void config_select_detector_put(const org::openapitools::server::model::Detector_selection &detectorSelection, - Pistache::Http::ResponseWriter &response) override; - - void detector_status_get(Pistache::Http::ResponseWriter &response) override; - - void config_spot_finding_get(Pistache::Http::ResponseWriter &response) override; - - void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, - Pistache::Http::ResponseWriter &response) override; - - void statistics_calibration_get(Pistache::Http::ResponseWriter &response) override; - - void statistics_data_collection_get(Pistache::Http::ResponseWriter &response) override; - - void cancel_post(Pistache::Http::ResponseWriter &response) override; - - void deactivate_post(Pistache::Http::ResponseWriter &response) override; - - void initialize_post(Pistache::Http::ResponseWriter &response) override; - - void start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings, - Pistache::Http::ResponseWriter &response) override; - - void status_get(Pistache::Http::ResponseWriter &response) override; - - void wait_till_done_post(const std::optional &timeoutMs, Pistache::Http::ResponseWriter &response) override; - void trigger_post(Pistache::Http::ResponseWriter &response) override; - void pedestal_post(Pistache::Http::ResponseWriter &response) override; - - void preview_pedestal_tiff_get(const std::optional &gainLevel, - const std::optional &sc, - Pistache::Http::ResponseWriter &response) override; - - void config_roi_get(Pistache::Http::ResponseWriter &response) override; - void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions, - Pistache::Http::ResponseWriter &response) override; - - void config_internal_generator_image_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) override; - - void xfel_event_code_get(Pistache::Http::ResponseWriter &response) override; - void xfel_pulse_id_get(Pistache::Http::ResponseWriter &response) override; - - void config_mask_tiff_get(Pistache::Http::ResponseWriter &response) override; - - void config_user_mask_tiff_get(Pistache::Http::ResponseWriter &response) override; - - void config_user_mask_tiff_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) override; - - void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) override; - - void config_instrument_get(Pistache::Http::ResponseWriter &response) override; - - void config_instrument_put(const org::openapitools::server::model::Instrument_metadata &instrumentMetadata, - Pistache::Http::ResponseWriter &response) override; - - void GetStaticFile(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - std::pair handleOperationException(const std::exception &ex) const noexcept override; - - template - void ProcessOutput(const T& output, Pistache::Http::ResponseWriter &response, bool compression = false) { - std::stringstream s; - if(!output.validate(s)) { - logger.Error(s.str()); - response.send(Pistache::Http::Code::Internal_Server_Error, s.str(), MIME(Text, Plain)); - } else { - nlohmann::json j = output; - if (compression) - response.setCompression(Pistache::Http::Header::Encoding::Deflate); - response.send(Pistache::Http::Code::Ok, j.dump(), MIME(Application, Json)); - } + static void send_plain(httplib::Response &res, int code, const std::string &body) { + res.status = code; + res.set_content(body, "text/plain"); } - void version_get(Pistache::Http::ResponseWriter &response) override; + template + void ProcessOutput(const T &output, httplib::Response &response) { + std::stringstream s; + if (!output.validate(s)) { + logger.Error(s.str()); + response.status = 500; + response.set_content(s.str(), "text/plain"); + return; + } - void config_image_format_conversion_post(Pistache::Http::ResponseWriter &response) override; + nlohmann::json j = output; + response.status = 200; + response.set_content(j.dump(), "application/json"); + } - void config_image_format_raw_post(Pistache::Http::ResponseWriter &response) override; + std::pair handleParsingException(const std::exception &ex) const noexcept; + std::pair handleOperationException(const std::exception &ex) const noexcept; - void statistics_get(const std::optional &compression, Pistache::Http::ResponseWriter &response) override; + void register_routes(httplib::Server &server); - void config_zeromq_preview_get(Pistache::Http::ResponseWriter &response) override; + void cancel_post(httplib::Response &response); + void deactivate_post(httplib::Response &response); + void initialize_post(httplib::Response &response); - void - config_zeromq_preview_put(const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings, - Pistache::Http::ResponseWriter &response) override; + void start_post(const org::openapitools::server::model::Dataset_settings &datasetSettings, + httplib::Response &response); + void status_get(httplib::Response &response); + void wait_till_done_post(const std::optional &timeout, httplib::Response &response); + void trigger_post(httplib::Response &response); + void pedestal_post(httplib::Response &response); - void config_zeromq_metadata_get(Pistache::Http::ResponseWriter &response) override; + void config_detector_get(httplib::Response &response); + void config_detector_put(const org::openapitools::server::model::Detector_settings &detectorSettings, + httplib::Response &response); - void config_zeromq_metadata_put( - const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings, - Pistache::Http::ResponseWriter &response) override; + void config_azim_int_get(httplib::Response &response); + void config_azim_int_put(const org::openapitools::server::model::Azim_int_settings &azimIntSettings, + httplib::Response &response); - void config_mask_get(Pistache::Http::ResponseWriter &response) override; + void config_select_detector_get(httplib::Response &response); + void config_select_detector_put(const org::openapitools::server::model::Detector_selection &detectorSelection, + httplib::Response &response); - void config_user_mask_get(Pistache::Http::ResponseWriter &response) override; + void config_spot_finding_get(httplib::Response &response); + void config_spot_finding_put(const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, + httplib::Response &response); - void config_user_mask_put(const Pistache::Rest::Request &request, - Pistache::Http::ResponseWriter &response) override; + void statistics_calibration_get(httplib::Response &response); + void statistics_data_collection_get(httplib::Response &response); - void image_buffer_clear_post(Pistache::Http::ResponseWriter &response) override; + void config_file_writer_get(httplib::Response &response); + void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings, + httplib::Response &response); - void image_buffer_image_cbor_get(const std::optional &id, - Pistache::Http::ResponseWriter &response) override; + void config_image_format_get(httplib::Response &response); + void config_image_format_put(const org::openapitools::server::model::Image_format_settings &imageFormatSettings, + httplib::Response &response); + void config_image_format_conversion_post(httplib::Response &response); + void config_image_format_raw_post(httplib::Response &response); - void image_buffer_image_jpeg_get(const std::optional &id, - const std::optional &showUserMask, - const std::optional &showRoi, - const std::optional &showSpots, - const std::optional &showBeamCenter, - const std::optional &saturation, - const std::optional &jpegQuality, - const std::optional &showResRing, - const std::optional &color, - const std::optional &showResEst, - Pistache::Http::ResponseWriter &response) override; + void fpga_status_get(httplib::Response &response); - void image_buffer_image_tiff_get(const std::optional &id, Pistache::Http::ResponseWriter &response) override; + void statistics_get(httplib::Response &response); - void image_buffer_start_cbor_get(Pistache::Http::ResponseWriter &response) override; + void config_zeromq_preview_get(httplib::Response &response); + void config_zeromq_preview_put(const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings, + httplib::Response &response); - void image_buffer_status_get(Pistache::Http::ResponseWriter &response) override; - void preview_plot_get(const std::optional &type, const std::optional &binning, - const std::optional &compression, const std::optional &fill, - const std::optional &experimentalCoord, const std::optional &azintUnit, - Pistache::Http::ResponseWriter &response) override; + void config_zeromq_metadata_get(httplib::Response &response); + void config_zeromq_metadata_put(const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings, + httplib::Response &response); + void config_internal_generator_image_put(const std::optional &id, + const httplib::Request &request, + httplib::Response &response); + + void config_internal_generator_image_tiff_put(const std::optional &id, + const httplib::Request &request, + httplib::Response &response); + + void image_buffer_clear_post(httplib::Response &response); + void image_buffer_image_cbor_get(const std::optional &id, httplib::Response &response); + void image_buffer_image_jpeg_get(const std::optional &id, const std::optional &showUserMask, + const std::optional &showRoi, const std::optional &showSpots, + const std::optional &showBeamCenter, const std::optional &saturation, + const std::optional &jpegQuality, const std::optional &showResRing, + const std::optional &color, const std::optional &showResEst, + httplib::Response &response); + void image_buffer_image_tiff_get(const std::optional &id, httplib::Response &response); + void image_buffer_start_cbor_get(httplib::Response &response); + void image_buffer_status_get(httplib::Response &response); + + void detector_status_get(httplib::Response &response); + void image_pusher_status_get(httplib::Response &response); + + void preview_pedestal_tiff_get(const std::optional &gainLevel, const std::optional &sc, + httplib::Response &response); void preview_plot_bin_get(const std::optional &type, const std::optional &roi, - Pistache::Http::ResponseWriter &response) override; + httplib::Response &response); + void preview_plot_get(const std::optional &type, const std::optional &binning, + const std::optional &fill, + const std::optional &experimentalCoord, const std::optional &azintUnit, + httplib::Response &response); - void config_indexing_get(Pistache::Http::ResponseWriter &response) override; + void config_mask_get(httplib::Response &response); + void config_mask_tiff_get(httplib::Response &response); + void config_user_mask_get(httplib::Response &response); + void config_user_mask_put(const httplib::Request &request, httplib::Response &response); + void config_user_mask_tiff_get(httplib::Response &response); + void config_user_mask_tiff_put(const httplib::Request &request, httplib::Response &response); + void config_roi_get(httplib::Response &response); + void config_roi_put(const org::openapitools::server::model::Roi_definitions &roiDefinitions, + httplib::Response &response); + + void result_scan_get(httplib::Response &response); + void version_get(httplib::Response &response); + + void config_instrument_get(httplib::Response &response); + void config_instrument_put(const org::openapitools::server::model::Instrument_metadata &instrumentMetadata, + httplib::Response &response); + + void config_indexing_get(httplib::Response &response); void config_indexing_put(const org::openapitools::server::model::Indexing_settings &indexingSettings, - Pistache::Http::ResponseWriter &response) override; + httplib::Response &response); - void result_scan_get(Pistache::Http::ResponseWriter &response) override; - - void config_dark_mask_get(Pistache::Http::ResponseWriter &response) override; + void config_dark_mask_get(httplib::Response &response); void config_dark_mask_put(const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, - Pistache::Http::ResponseWriter &response) override; - void image_pusher_status_get(Pistache::Http::ResponseWriter &response) override; + httplib::Response &response); + + void xfel_event_code_get(httplib::Response &response); + void xfel_pulse_id_get(httplib::Response &response); public: - JFJochBrokerHttp(const DiffractionExperiment& experiment, - const SpotFindingSettings &spot_finding_settings, - std::shared_ptr &rtr); + JFJochBrokerHttp(const DiffractionExperiment &experiment, + const SpotFindingSettings &spot_finding_settings); void AddDetectorSetup(const DetectorSetup &setup); - JFJochServices& Services(); + JFJochServices &Services(); + JFJochBrokerHttp &FrontendDirectory(const std::string &directory); + void attach(httplib::Server &server); - JFJochBrokerHttp& FrontendDirectory(const std::string &directory); - - ~JFJochBrokerHttp() override = default; - -private: - void config_file_writer_get(Pistache::Http::ResponseWriter &response) override; - - void config_file_writer_put(const org::openapitools::server::model::File_writer_settings &fileWriterSettings, - Pistache::Http::ResponseWriter &response) override; + ~JFJochBrokerHttp() = default; }; - - -#endif //JUNGFRAUJOCH_JFJOCHBROKERHTTP_H diff --git a/broker/OpenAPIConvert.cpp b/broker/OpenAPIConvert.cpp index f6414d57..8bcfd823 100644 --- a/broker/OpenAPIConvert.cpp +++ b/broker/OpenAPIConvert.cpp @@ -870,7 +870,6 @@ PlotType ConvertPlotType(const std::optional& input) { if (input == "packets_received") return PlotType::PacketsReceived; if (input == "max_pixel_value") return PlotType::MaxValue; if (input == "resolution_estimate") return PlotType::ResolutionEstimate; - if (input == "indexing_time") return PlotType::IndexingTime; if (input == "pixel_sum") return PlotType::PixelSum; if (input == "processing_time") return PlotType::ImageProcessingTime; if (input == "beam_center_x") return PlotType::RefinementBeamX; diff --git a/broker/gen/api/ApiBase.cpp b/broker/gen/api/ApiBase.cpp deleted file mode 100644 index 28074574..00000000 --- a/broker/gen/api/ApiBase.cpp +++ /dev/null @@ -1,22 +0,0 @@ -/** -* 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.132 -* Contact: filip.leonarski@psi.ch -* -* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). -* https://openapi-generator.tech -* Do not edit the class manually. -*/ -#include "ApiBase.h" - -namespace org::openapitools::server::api -{ - -ApiBase::ApiBase(const std::shared_ptr& rtr) : router(rtr) -{ -} - - -} // Namespace org::openapitools::server::api diff --git a/broker/gen/api/ApiBase.h b/broker/gen/api/ApiBase.h deleted file mode 100644 index 5a44dff3..00000000 --- a/broker/gen/api/ApiBase.h +++ /dev/null @@ -1,51 +0,0 @@ -/** -* 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.132 -* Contact: filip.leonarski@psi.ch -* -* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). -* https://openapi-generator.tech -* Do not edit the class manually. -*/ -/* - * ApiBase.h - * - * Generalization of the Api classes - */ - -#ifndef ApiBase_H_ -#define ApiBase_H_ - -#include -#include - -namespace org::openapitools::server::api -{ - - - - - -class ApiBase { -public: - explicit ApiBase(const std::shared_ptr& rtr); - virtual ~ApiBase() = default; - virtual void init() = 0; - - - - - -protected: - const std::shared_ptr router; - - - - -}; - -} // namespace org::openapitools::server::api - -#endif /* ApiBase_H_ */ diff --git a/broker/gen/api/DefaultApi.cpp b/broker/gen/api/DefaultApi.cpp deleted file mode 100644 index 8582287a..00000000 --- a/broker/gen/api/DefaultApi.cpp +++ /dev/null @@ -1,2279 +0,0 @@ -/** -* 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.132 -* Contact: filip.leonarski@psi.ch -* -* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). -* https://openapi-generator.tech -* Do not edit the class manually. -*/ - -#include "DefaultApi.h" -#include "Helpers.h" - -namespace org::openapitools::server::api -{ - -using namespace org::openapitools::server::helpers; -using namespace org::openapitools::server::model; - -const std::string DefaultApi::base = ""; - -DefaultApi::DefaultApi(const std::shared_ptr& rtr) - : ApiBase(rtr) -{} - -void DefaultApi::init() { - setupRoutes(); -} - -void DefaultApi::setupRoutes() { - using namespace Pistache::Rest; - - Routes::Post(*router, base + "/cancel", Routes::bind(&DefaultApi::cancel_post_handler, this)); - Routes::Get(*router, base + "/config/azim_int", Routes::bind(&DefaultApi::config_azim_int_get_handler, this)); - Routes::Put(*router, base + "/config/azim_int", Routes::bind(&DefaultApi::config_azim_int_put_handler, this)); - Routes::Get(*router, base + "/config/dark_mask", Routes::bind(&DefaultApi::config_dark_mask_get_handler, this)); - Routes::Put(*router, base + "/config/dark_mask", Routes::bind(&DefaultApi::config_dark_mask_put_handler, this)); - Routes::Get(*router, base + "/config/detector", Routes::bind(&DefaultApi::config_detector_get_handler, this)); - Routes::Put(*router, base + "/config/detector", Routes::bind(&DefaultApi::config_detector_put_handler, this)); - Routes::Get(*router, base + "/config/file_writer", Routes::bind(&DefaultApi::config_file_writer_get_handler, this)); - Routes::Put(*router, base + "/config/file_writer", Routes::bind(&DefaultApi::config_file_writer_put_handler, this)); - Routes::Post(*router, base + "/config/image_format/conversion", Routes::bind(&DefaultApi::config_image_format_conversion_post_handler, this)); - Routes::Get(*router, base + "/config/image_format", Routes::bind(&DefaultApi::config_image_format_get_handler, this)); - Routes::Put(*router, base + "/config/image_format", Routes::bind(&DefaultApi::config_image_format_put_handler, this)); - Routes::Post(*router, base + "/config/image_format/raw", Routes::bind(&DefaultApi::config_image_format_raw_post_handler, this)); - Routes::Get(*router, base + "/config/indexing", Routes::bind(&DefaultApi::config_indexing_get_handler, this)); - Routes::Put(*router, base + "/config/indexing", Routes::bind(&DefaultApi::config_indexing_put_handler, this)); - Routes::Get(*router, base + "/config/instrument", Routes::bind(&DefaultApi::config_instrument_get_handler, this)); - Routes::Put(*router, base + "/config/instrument", Routes::bind(&DefaultApi::config_instrument_put_handler, this)); - Routes::Put(*router, base + "/config/internal_generator_image", Routes::bind(&DefaultApi::config_internal_generator_image_put_handler, this)); - Routes::Put(*router, base + "/config/internal_generator_image.tiff", Routes::bind(&DefaultApi::config_internal_generator_image_tiff_put_handler, this)); - Routes::Get(*router, base + "/config/mask", Routes::bind(&DefaultApi::config_mask_get_handler, this)); - Routes::Get(*router, base + "/config/mask.tiff", Routes::bind(&DefaultApi::config_mask_tiff_get_handler, this)); - Routes::Get(*router, base + "/config/roi", Routes::bind(&DefaultApi::config_roi_get_handler, this)); - Routes::Put(*router, base + "/config/roi", Routes::bind(&DefaultApi::config_roi_put_handler, this)); - Routes::Get(*router, base + "/config/select_detector", Routes::bind(&DefaultApi::config_select_detector_get_handler, this)); - Routes::Put(*router, base + "/config/select_detector", Routes::bind(&DefaultApi::config_select_detector_put_handler, this)); - Routes::Get(*router, base + "/config/spot_finding", Routes::bind(&DefaultApi::config_spot_finding_get_handler, this)); - Routes::Put(*router, base + "/config/spot_finding", Routes::bind(&DefaultApi::config_spot_finding_put_handler, this)); - Routes::Get(*router, base + "/config/user_mask", Routes::bind(&DefaultApi::config_user_mask_get_handler, this)); - Routes::Put(*router, base + "/config/user_mask", Routes::bind(&DefaultApi::config_user_mask_put_handler, this)); - Routes::Get(*router, base + "/config/user_mask.tiff", Routes::bind(&DefaultApi::config_user_mask_tiff_get_handler, this)); - Routes::Put(*router, base + "/config/user_mask.tiff", Routes::bind(&DefaultApi::config_user_mask_tiff_put_handler, this)); - Routes::Get(*router, base + "/config/zeromq_metadata", Routes::bind(&DefaultApi::config_zeromq_metadata_get_handler, this)); - Routes::Put(*router, base + "/config/zeromq_metadata", Routes::bind(&DefaultApi::config_zeromq_metadata_put_handler, this)); - Routes::Get(*router, base + "/config/zeromq_preview", Routes::bind(&DefaultApi::config_zeromq_preview_get_handler, this)); - Routes::Put(*router, base + "/config/zeromq_preview", Routes::bind(&DefaultApi::config_zeromq_preview_put_handler, this)); - Routes::Post(*router, base + "/deactivate", Routes::bind(&DefaultApi::deactivate_post_handler, this)); - Routes::Get(*router, base + "/detector/status", Routes::bind(&DefaultApi::detector_status_get_handler, this)); - Routes::Get(*router, base + "/fpga_status", Routes::bind(&DefaultApi::fpga_status_get_handler, this)); - Routes::Post(*router, base + "/image_buffer/clear", Routes::bind(&DefaultApi::image_buffer_clear_post_handler, this)); - Routes::Get(*router, base + "/image_buffer/image.cbor", Routes::bind(&DefaultApi::image_buffer_image_cbor_get_handler, this)); - Routes::Get(*router, base + "/image_buffer/image.jpeg", Routes::bind(&DefaultApi::image_buffer_image_jpeg_get_handler, this)); - Routes::Get(*router, base + "/image_buffer/image.tiff", Routes::bind(&DefaultApi::image_buffer_image_tiff_get_handler, this)); - Routes::Get(*router, base + "/image_buffer/start.cbor", Routes::bind(&DefaultApi::image_buffer_start_cbor_get_handler, this)); - Routes::Get(*router, base + "/image_buffer/status", Routes::bind(&DefaultApi::image_buffer_status_get_handler, this)); - Routes::Get(*router, base + "/image_pusher/status", Routes::bind(&DefaultApi::image_pusher_status_get_handler, this)); - Routes::Post(*router, base + "/initialize", Routes::bind(&DefaultApi::initialize_post_handler, this)); - Routes::Post(*router, base + "/pedestal", Routes::bind(&DefaultApi::pedestal_post_handler, this)); - Routes::Get(*router, base + "/preview/pedestal.tiff", Routes::bind(&DefaultApi::preview_pedestal_tiff_get_handler, this)); - Routes::Get(*router, base + "/preview/plot.bin", Routes::bind(&DefaultApi::preview_plot_bin_get_handler, this)); - Routes::Get(*router, base + "/preview/plot", Routes::bind(&DefaultApi::preview_plot_get_handler, this)); - Routes::Get(*router, base + "/result/scan", Routes::bind(&DefaultApi::result_scan_get_handler, this)); - Routes::Post(*router, base + "/start", Routes::bind(&DefaultApi::start_post_handler, this)); - Routes::Get(*router, base + "/statistics/calibration", Routes::bind(&DefaultApi::statistics_calibration_get_handler, this)); - Routes::Get(*router, base + "/statistics/data_collection", Routes::bind(&DefaultApi::statistics_data_collection_get_handler, this)); - Routes::Get(*router, base + "/statistics", Routes::bind(&DefaultApi::statistics_get_handler, this)); - Routes::Get(*router, base + "/status", Routes::bind(&DefaultApi::status_get_handler, this)); - Routes::Post(*router, base + "/trigger", Routes::bind(&DefaultApi::trigger_post_handler, this)); - Routes::Get(*router, base + "/version", Routes::bind(&DefaultApi::version_get_handler, this)); - Routes::Post(*router, base + "/wait_till_done", Routes::bind(&DefaultApi::wait_till_done_post_handler, this)); - Routes::Get(*router, base + "/xfel/event_code", Routes::bind(&DefaultApi::xfel_event_code_get_handler, this)); - Routes::Get(*router, base + "/xfel/pulse_id", Routes::bind(&DefaultApi::xfel_pulse_id_get_handler, this)); - - // Default handler, called when a route is not found - router->addCustomHandler(Routes::bind(&DefaultApi::default_api_default_handler, this)); -} - -void DefaultApi::handleParsingException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept { - std::pair codeAndError = handleParsingException(ex); - response.send(codeAndError.first, codeAndError.second); -} - -std::pair DefaultApi::handleParsingException(const std::exception& ex) const noexcept { - try { - throw; - } catch (nlohmann::detail::exception &e) { - return std::make_pair(Pistache::Http::Code::Bad_Request, e.what()); - } catch (org::openapitools::server::helpers::ValidationException &e) { - return std::make_pair(Pistache::Http::Code::Bad_Request, e.what()); - } catch (std::exception &e) { - return std::make_pair(Pistache::Http::Code::Internal_Server_Error, e.what()); - } -} - -void DefaultApi::handleOperationException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept { - std::pair codeAndError = handleOperationException(ex); - response.send(codeAndError.first, codeAndError.second); -} - -std::pair DefaultApi::handleOperationException(const std::exception& ex) const noexcept { - return std::make_pair(Pistache::Http::Code::Internal_Server_Error, ex.what()); -} - -void DefaultApi::cancel_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->cancel_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_azim_int_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_azim_int_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_azim_int_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Azim_int_settings azimIntSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(azimIntSettings); - azimIntSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_azim_int_put(azimIntSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_dark_mask_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_dark_mask_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_dark_mask_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Dark_mask_settings darkMaskSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(darkMaskSettings); - darkMaskSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_dark_mask_put(darkMaskSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_detector_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_detector_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_detector_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Detector_settings detectorSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(detectorSettings); - detectorSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_detector_put(detectorSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_file_writer_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_file_writer_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_file_writer_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - File_writer_settings fileWriterSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(fileWriterSettings); - fileWriterSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_file_writer_put(fileWriterSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_image_format_conversion_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_image_format_conversion_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_image_format_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_image_format_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_image_format_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Image_format_settings imageFormatSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(imageFormatSettings); - imageFormatSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_image_format_put(imageFormatSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_image_format_raw_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_image_format_raw_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_indexing_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_indexing_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_indexing_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Indexing_settings indexingSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(indexingSettings); - indexingSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_indexing_put(indexingSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_instrument_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_instrument_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_instrument_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Instrument_metadata instrumentMetadata; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(instrumentMetadata); - instrumentMetadata.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_instrument_put(instrumentMetadata, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_internal_generator_image_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - try { - this->config_internal_generator_image_put(request, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_internal_generator_image_tiff_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - try { - this->config_internal_generator_image_tiff_put(request, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_mask_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_mask_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_mask_tiff_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_mask_tiff_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_roi_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_roi_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_roi_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Roi_definitions roiDefinitions; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(roiDefinitions); - roiDefinitions.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_roi_put(roiDefinitions, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_select_detector_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_select_detector_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_select_detector_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Detector_selection detectorSelection; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(detectorSelection); - detectorSelection.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_select_detector_put(detectorSelection, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_spot_finding_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_spot_finding_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_spot_finding_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Spot_finding_settings spotFindingSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(spotFindingSettings); - spotFindingSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_spot_finding_put(spotFindingSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_user_mask_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_user_mask_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_user_mask_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - try { - this->config_user_mask_put(request, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_user_mask_tiff_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_user_mask_tiff_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_user_mask_tiff_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - try { - this->config_user_mask_tiff_put(request, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_zeromq_metadata_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_zeromq_metadata_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_zeromq_metadata_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Zeromq_metadata_settings zeromqMetadataSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(zeromqMetadataSettings); - zeromqMetadataSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_zeromq_metadata_put(zeromqMetadataSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_zeromq_preview_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->config_zeromq_preview_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::config_zeromq_preview_put_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Zeromq_preview_settings zeromqPreviewSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(zeromqPreviewSettings); - zeromqPreviewSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->config_zeromq_preview_put(zeromqPreviewSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::deactivate_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->deactivate_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::detector_status_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->detector_status_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::fpga_status_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->fpga_status_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_clear_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->image_buffer_clear_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_image_cbor_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto idQuery = request.query().get("id"); - std::optional id; - if (idQuery.has_value()) { - int64_t valueQuery_instance; - if (fromStringValue(idQuery.value(), valueQuery_instance)) { - id = valueQuery_instance; - } - } - - - - try { - - - - - - this->image_buffer_image_cbor_get(id, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_image_jpeg_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto idQuery = request.query().get("id"); - std::optional id; - if (idQuery.has_value()) { - int64_t valueQuery_instance; - if (fromStringValue(idQuery.value(), valueQuery_instance)) { - id = valueQuery_instance; - } - } - auto showUserMaskQuery = request.query().get("show_user_mask"); - std::optional showUserMask; - if (showUserMaskQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(showUserMaskQuery.value(), valueQuery_instance)) { - showUserMask = valueQuery_instance; - } - } - auto showRoiQuery = request.query().get("show_roi"); - std::optional showRoi; - if (showRoiQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(showRoiQuery.value(), valueQuery_instance)) { - showRoi = valueQuery_instance; - } - } - auto showSpotsQuery = request.query().get("show_spots"); - std::optional showSpots; - if (showSpotsQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(showSpotsQuery.value(), valueQuery_instance)) { - showSpots = valueQuery_instance; - } - } - auto showBeamCenterQuery = request.query().get("show_beam_center"); - std::optional showBeamCenter; - if (showBeamCenterQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(showBeamCenterQuery.value(), valueQuery_instance)) { - showBeamCenter = valueQuery_instance; - } - } - auto saturationQuery = request.query().get("saturation"); - std::optional saturation; - if (saturationQuery.has_value()) { - float valueQuery_instance; - if (fromStringValue(saturationQuery.value(), valueQuery_instance)) { - saturation = valueQuery_instance; - } - } - auto jpegQualityQuery = request.query().get("jpeg_quality"); - std::optional jpegQuality; - if (jpegQualityQuery.has_value()) { - int64_t valueQuery_instance; - if (fromStringValue(jpegQualityQuery.value(), valueQuery_instance)) { - jpegQuality = valueQuery_instance; - } - } - auto showResRingQuery = request.query().get("show_res_ring"); - std::optional showResRing; - if (showResRingQuery.has_value()) { - float valueQuery_instance; - if (fromStringValue(showResRingQuery.value(), valueQuery_instance)) { - showResRing = valueQuery_instance; - } - } - auto colorQuery = request.query().get("color"); - std::optional color; - if (colorQuery.has_value()) { - std::string valueQuery_instance; - if (fromStringValue(colorQuery.value(), valueQuery_instance)) { - color = valueQuery_instance; - } - } - auto showResEstQuery = request.query().get("show_res_est"); - std::optional showResEst; - if (showResEstQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(showResEstQuery.value(), valueQuery_instance)) { - showResEst = valueQuery_instance; - } - } - - - - try { - - - - - - this->image_buffer_image_jpeg_get(id, showUserMask, showRoi, showSpots, showBeamCenter, saturation, jpegQuality, showResRing, color, showResEst, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_image_tiff_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto idQuery = request.query().get("id"); - std::optional id; - if (idQuery.has_value()) { - int64_t valueQuery_instance; - if (fromStringValue(idQuery.value(), valueQuery_instance)) { - id = valueQuery_instance; - } - } - - - - try { - - - - - - this->image_buffer_image_tiff_get(id, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_start_cbor_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->image_buffer_start_cbor_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_buffer_status_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->image_buffer_status_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::image_pusher_status_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->image_pusher_status_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::initialize_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->initialize_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::pedestal_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->pedestal_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::preview_pedestal_tiff_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto gainLevelQuery = request.query().get("gain_level"); - std::optional gainLevel; - if (gainLevelQuery.has_value()) { - int32_t valueQuery_instance; - if (fromStringValue(gainLevelQuery.value(), valueQuery_instance)) { - gainLevel = valueQuery_instance; - } - } - auto scQuery = request.query().get("sc"); - std::optional sc; - if (scQuery.has_value()) { - int32_t valueQuery_instance; - if (fromStringValue(scQuery.value(), valueQuery_instance)) { - sc = valueQuery_instance; - } - } - - - - try { - - - - - - this->preview_pedestal_tiff_get(gainLevel, sc, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::preview_plot_bin_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto typeQuery = request.query().get("type"); - std::optional type; - if (typeQuery.has_value()) { - std::string valueQuery_instance; - if (fromStringValue(typeQuery.value(), valueQuery_instance)) { - type = valueQuery_instance; - } - } - auto roiQuery = request.query().get("roi"); - std::optional roi; - if (roiQuery.has_value()) { - std::string valueQuery_instance; - if (fromStringValue(roiQuery.value(), valueQuery_instance)) { - roi = valueQuery_instance; - } - } - - - - try { - - - - - - this->preview_plot_bin_get(type, roi, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::preview_plot_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto binningQuery = request.query().get("binning"); - std::optional binning; - if (binningQuery.has_value()) { - int32_t valueQuery_instance; - if (fromStringValue(binningQuery.value(), valueQuery_instance)) { - binning = valueQuery_instance; - } - } - auto compressionQuery = request.query().get("compression"); - std::optional compression; - if (compressionQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(compressionQuery.value(), valueQuery_instance)) { - compression = valueQuery_instance; - } - } - auto typeQuery = request.query().get("type"); - std::optional type; - if (typeQuery.has_value()) { - std::string valueQuery_instance; - if (fromStringValue(typeQuery.value(), valueQuery_instance)) { - type = valueQuery_instance; - } - } - auto fillQuery = request.query().get("fill"); - std::optional fill; - if (fillQuery.has_value()) { - float valueQuery_instance; - if (fromStringValue(fillQuery.value(), valueQuery_instance)) { - fill = valueQuery_instance; - } - } - auto experimentalCoordQuery = request.query().get("experimental_coord"); - std::optional experimentalCoord; - if (experimentalCoordQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(experimentalCoordQuery.value(), valueQuery_instance)) { - experimentalCoord = valueQuery_instance; - } - } - auto azintUnitQuery = request.query().get("azint_unit"); - std::optional azintUnit; - if (azintUnitQuery.has_value()) { - std::string valueQuery_instance; - if (fromStringValue(azintUnitQuery.value(), valueQuery_instance)) { - azintUnit = valueQuery_instance; - } - } - - - - try { - - - - - - this->preview_plot_get(type, binning, compression, fill, experimentalCoord, azintUnit, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::result_scan_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->result_scan_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::start_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - // Getting the body param - - Dataset_settings datasetSettings; - - - - - - try { - nlohmann::json::parse(request.body()).get_to(datasetSettings); - datasetSettings.validate(); - } catch (std::exception& e) { - this->handleParsingException(e, response); - return; - } - - try { - - - - - - this->start_post(datasetSettings, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::statistics_calibration_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->statistics_calibration_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::statistics_data_collection_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->statistics_data_collection_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::statistics_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto compressionQuery = request.query().get("compression"); - std::optional compression; - if (compressionQuery.has_value()) { - bool valueQuery_instance; - if (fromStringValue(compressionQuery.value(), valueQuery_instance)) { - compression = valueQuery_instance; - } - } - - - - try { - - - - - - this->statistics_get(compression, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::status_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->status_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::trigger_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->trigger_post(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::version_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->version_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::wait_till_done_post_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - // Getting the query params - auto timeoutQuery = request.query().get("timeout"); - std::optional timeout; - if (timeoutQuery.has_value()) { - int32_t valueQuery_instance; - if (fromStringValue(timeoutQuery.value(), valueQuery_instance)) { - timeout = valueQuery_instance; - } - } - - - - try { - - - - - - this->wait_till_done_post(timeout, response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::xfel_event_code_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->xfel_event_code_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - -void DefaultApi::xfel_pulse_id_get_handler(const Pistache::Rest::Request& request, Pistache::Http::ResponseWriter response) { - try { - - - - - - - try { - - - - - - this->xfel_pulse_id_get(response); - } catch (Pistache::Http::HttpError &e) { - response.send(static_cast(e.code()), e.what()); - return; - } catch (std::exception &e) { - this->handleOperationException(e, response); - return; - } - - } catch (std::exception &e) { - response.send(Pistache::Http::Code::Internal_Server_Error, e.what()); - } - - -} - - -void DefaultApi::default_api_default_handler(const Pistache::Rest::Request &, Pistache::Http::ResponseWriter response) { - response.send(Pistache::Http::Code::Not_Found, "The requested method does not exist"); -} - -} // namespace org::openapitools::server::api - diff --git a/broker/gen/api/DefaultApi.h b/broker/gen/api/DefaultApi.h deleted file mode 100644 index 2e6fac0c..00000000 --- a/broker/gen/api/DefaultApi.h +++ /dev/null @@ -1,634 +0,0 @@ -/** -* 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.132 -* Contact: filip.leonarski@psi.ch -* -* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). -* https://openapi-generator.tech -* Do not edit the class manually. -*/ -/* - * DefaultApi.h - * - * - */ - -#ifndef DefaultApi_H_ -#define DefaultApi_H_ - - -#include "ApiBase.h" - -#include -#include -#include - -#include -#include - -#include "Azim_int_settings.h" -#include "Broker_status.h" -#include "Calibration_statistics_inner.h" -#include "Dark_mask_settings.h" -#include "Dataset_settings.h" -#include "Detector_list.h" -#include "Detector_selection.h" -#include "Detector_settings.h" -#include "Detector_status.h" -#include "Error_message.h" -#include "File_writer_settings.h" -#include "Fpga_status_inner.h" -#include "Image_buffer_status.h" -#include "Image_format_settings.h" -#include "Image_pusher_status.h" -#include "Indexing_settings.h" -#include "Instrument_metadata.h" -#include "Jfjoch_statistics.h" -#include "Measurement_statistics.h" -#include "Plots.h" -#include "Roi_definitions.h" -#include "Scan_result.h" -#include "Spot_finding_settings.h" -#include "Zeromq_metadata_settings.h" -#include "Zeromq_preview_settings.h" -#include -#include - -namespace org::openapitools::server::api -{ - -class DefaultApi : public ApiBase { -public: - explicit DefaultApi(const std::shared_ptr& rtr); - ~DefaultApi() override = default; - void init() override; - - static const std::string base; - -private: - void setupRoutes(); - - void cancel_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_azim_int_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_azim_int_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_dark_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_dark_mask_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_file_writer_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_file_writer_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_image_format_conversion_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_image_format_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_image_format_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_image_format_raw_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_indexing_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_indexing_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_instrument_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_instrument_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_internal_generator_image_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_internal_generator_image_tiff_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_mask_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_roi_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_roi_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_select_detector_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_select_detector_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_spot_finding_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_spot_finding_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_user_mask_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_user_mask_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_user_mask_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_user_mask_tiff_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_zeromq_metadata_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_zeromq_metadata_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_zeromq_preview_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void config_zeromq_preview_put_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void deactivate_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void detector_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void fpga_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_clear_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_image_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_image_jpeg_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_image_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_start_cbor_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_buffer_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void image_pusher_status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void initialize_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void pedestal_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void preview_pedestal_tiff_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void preview_plot_bin_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void preview_plot_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void result_scan_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void start_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void statistics_calibration_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void statistics_data_collection_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void statistics_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void status_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void trigger_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void version_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void wait_till_done_post_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void xfel_event_code_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void xfel_pulse_id_get_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - void default_api_default_handler(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter response); - - /// - /// Helper function to handle unexpected Exceptions during Parameter parsing and validation. - /// May be overridden to return custom error formats. This is called inside a catch block. - /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`. - /// - virtual void handleParsingException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept; - - /// - /// Helper function to handle unexpected Exceptions during Parameter parsing and validation. - /// May be overridden to return custom error formats. This is called inside a catch block. - /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`. - /// - virtual std::pair handleParsingException(const std::exception& ex) const noexcept; - - /// - /// Helper function to handle unexpected Exceptions during processing of the request in handler functions. - /// May be overridden to return custom error formats. This is called inside a catch block. - /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`. - /// - virtual void handleOperationException(const std::exception& ex, Pistache::Http::ResponseWriter &response) const noexcept; - - /// - /// Helper function to handle unexpected Exceptions during processing of the request in handler functions. - /// May be overridden to return custom error formats. This is called inside a catch block. - /// Important: When overriding, do not call `throw ex;`, but instead use `throw;`. - /// - virtual std::pair handleOperationException(const std::exception& ex) const noexcept; - - /// - /// Cancel running data collection - /// - /// - /// Command will inform FPGA network card to stop pedestal or data collection at the current stage. Any frame that is currently being processed by CPU will be finished and sent to writer. Given the command is making sure to gracefully stop data acquisition and detector, it might take some time to switch back after command finished to `Idle` state. If data collection is not running, the command has no effect. - /// - virtual void cancel_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get azimuthal integration configuration - /// - /// - /// Can be done anytime - /// - virtual void config_azim_int_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Configure azimuthal integration - /// - /// - /// Can be done when detector is Inactive or Idle - /// - /// (optional) - virtual void config_azim_int_put( const org::openapitools::server::model::Azim_int_settings &azimIntSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get settings for dark data collection to calculate mask - /// - /// - /// - /// - virtual void config_dark_mask_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Set configuration for dark data collection to calculate mask - /// - /// - /// This is only possible when operating DECTRIS detectors at the moment; it will be also available for PSI EIGER at some point. This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - /// (optional) - virtual void config_dark_mask_put( const org::openapitools::server::model::Dark_mask_settings &darkMaskSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get detector configuration - /// - /// - /// Can be done anytime - /// - virtual void config_detector_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Change detector configuration - /// - /// - /// Detector settings are ones that have effect on calibration, i.e., pedestal has to be collected again after changing these settings. This can only be done when detector is `Idle`, `Error` or `Inactive` states. If detector is in `Idle` state , pedestal procedure will be executed automatically - there must be no X-rays on the detector during the operation. If detector is in `Inactive` or `Error` states, new settings will be saved, but no calibration will be executed. - /// - /// (optional) - virtual void config_detector_put( const org::openapitools::server::model::Detector_settings &detectorSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get file writer settings - /// - /// - /// Can be done anytime - /// - virtual void config_file_writer_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Change file writer settings - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - /// (optional) - virtual void config_file_writer_put( const org::openapitools::server::model::File_writer_settings &fileWriterSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Configure format for data collection with full conversion - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - virtual void config_image_format_conversion_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get image output format - /// - /// - /// Can be done anytime - /// - virtual void config_image_format_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Change image output format - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - /// (optional) - virtual void config_image_format_put( const org::openapitools::server::model::Image_format_settings &imageFormatSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Configure format for raw data collection - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - virtual void config_image_format_raw_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get indexing configuration - /// - /// - /// Can be done anytime - /// - virtual void config_indexing_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Change indexing algorithm settings - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - /// (optional) - virtual void config_indexing_put( const org::openapitools::server::model::Indexing_settings &indexingSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get instrument metadata - /// - /// - /// Can be done anytime - /// - virtual void config_instrument_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Change instrument metadata - /// - /// - /// This can only be done when detector is `Idle`, `Error` or `Inactive` states. - /// - /// (optional) - virtual void config_instrument_put( const org::openapitools::server::model::Instrument_metadata &instrumentMetadata, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Load binary image for internal FPGA generator - /// - /// - /// Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires binary blob with 16-bit integer numbers of size of detector in raw/converted coordinates (depending on detector settings). - /// - virtual void config_internal_generator_image_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Load TIFF image for internal FPGA generator - /// - /// - /// Load image for internal FPGA generator. This can only happen in Idle state of the detector. Requires TIFF with 16-bit integer numbers of size of detector in raw/converted coordinates (depending on detector settings). - /// - virtual void config_internal_generator_image_tiff_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get mask of the detector (binary) - /// - /// - /// Detector must be Initialized. Get full pixel mask of the detector. See NXmx standard for meaning of pixel values. - /// - virtual void config_mask_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get mask of the detector (TIFF) - /// - /// - /// Should be in `Idle` state. Get full pixel mask of the detector See NXmx standard for meaning of pixel values - /// - virtual void config_mask_tiff_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get ROI definitions - /// - /// - /// - /// - virtual void config_roi_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Upload ROI definitions - /// - /// - /// - /// - /// (optional) - virtual void config_roi_put( const org::openapitools::server::model::Roi_definitions &roiDefinitions, Pistache::Http::ResponseWriter &response) = 0; - /// - /// List available detectors - /// - /// - /// Configured detectors that can be selected by used - /// - virtual void config_select_detector_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Select detector - /// - /// - /// Jungfraujoch allows to control multiple detectors and/or region-of-interests. The command allows to choose one detector from the list (ID has to be consistent with one provided by GET response). Changing detector will set detector to `Inactive` state and will require reinitialization. - /// - /// (optional) - virtual void config_select_detector_put( const org::openapitools::server::model::Detector_selection &detectorSelection, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get data processing configuration - /// - /// - /// Can be done anytime - /// - virtual void config_spot_finding_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Configure spot finding - /// - /// - /// Can be done anytime, also while data collection is running - /// - /// (optional) - virtual void config_spot_finding_put( const org::openapitools::server::model::Spot_finding_settings &spotFindingSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Detector must be Initialized. Get user mask of the detector (binary) - /// - /// - /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked - /// - virtual void config_user_mask_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Upload user mask of the detector (binary) - /// - /// - /// Should be in `Idle` state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don't need to be assigned value. Mask is expected as binary array (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration. - /// - virtual void config_user_mask_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Detector must be Initialized. Get user mask of the detector (TIFF) - /// - /// - /// Get user pixel mask of the detector in the actual detector coordinates: 0 - good pixel, 1 - masked - /// - virtual void config_user_mask_tiff_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Upload user mask of the detector - /// - /// - /// Should be in `Idle` state. Upload user mask of the detector - this is for example to account for beam stop shadow or misbehaving regions. If detector is conversion mode the mask can be both in raw (1024x512; stacked modules) or converted coordinates. In the latter case - module gaps are ignored and don't need to be assigned value. Mask is expected as TIFF (4-byte; unsigned). 0 - good pixel, other value - masked User mask is stored in NXmx pixel mask (bit 8), as well as used in spot finding and azimuthal integration. User mask is not automatically applied - i.e. pixels with user mask will have a valid pixel value in the images. - /// - virtual void config_user_mask_tiff_put(const Pistache::Rest::Request &request, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get ZeroMQ metadata socket settings - /// - /// - /// - /// - virtual void config_zeromq_metadata_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Set ZeroMQ metadata settings - /// - /// - /// Jungfraujoch can generate metadata message stream on ZeroMQ PUB socket. This stream covers all images. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request. - /// - /// (optional) - virtual void config_zeromq_metadata_put( const org::openapitools::server::model::Zeromq_metadata_settings &zeromqMetadataSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get ZeroMQ preview settings - /// - /// - /// - /// - virtual void config_zeromq_preview_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Set ZeroMQ preview settings - /// - /// - /// Jungfraujoch can generate preview message stream on ZeroMQ SUB socket. Here settings of the socket can be adjusted. While the data structure contains also socket_address, this cannot be changed via HTTP and is ignore in PUT request. Options set with this PUT request have no effect on HTTP based preview. - /// - /// (optional) - virtual void config_zeromq_preview_put( const org::openapitools::server::model::Zeromq_preview_settings &zeromqPreviewSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Prepare detector to turn off - /// - /// - /// Should be in `Idle` or `Error` state. Command deactivates data acquisition and turns off detector high voltage and ASIC. Should be used always before turning off power from the detector. - /// - virtual void deactivate_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get detector status - /// - /// - /// Status of the JUNGFRAU detector - /// - virtual void detector_status_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get status of FPGA devices - /// - /// - /// - /// - virtual void fpga_status_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Clear image buffer - /// - /// - /// Turns off image buffer for the last data collection. Can be only run when Jungfraujoch is not collecting data. - /// - virtual void image_buffer_clear_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get image message in CBOR format - /// - /// - /// Contains full image data and metadata. The image must come from the latest data collection. - /// - /// Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L) - virtual void image_buffer_image_cbor_get( const std::optional &id, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get preview image in JPEG format using custom settings - /// - /// - /// - /// - /// Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L) - /// Show user mask (optional, default to false) - /// Show ROI areas on the image (optional, default to false) - /// Show spot finding results on the image (optional, default to true) - /// Show beam center on the image (optional, default to true) - /// Saturation value to set contrast in the preview image; if not provided, then autocontrast procedure is used (optional, default to 0.0f) - /// Quality of JPEG image (100 - highest; 0 - lowest) (optional, default to 100L) - /// Show resolution ring, provided in Angstrom (optional, default to 0.1f) - /// Color scale for preview image (optional, default to "indigo") - /// Show resolution estimation as a ring (optional, default to false) - virtual void image_buffer_image_jpeg_get( const std::optional &id, const std::optional &showUserMask, const std::optional &showRoi, const std::optional &showSpots, const std::optional &showBeamCenter, const std::optional &saturation, const std::optional &jpegQuality, const std::optional &showResRing, const std::optional &color, const std::optional &showResEst, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get preview image in TIFF format - /// - /// - /// - /// - /// Image ID in the image buffer. Special values: -1 - last image in the buffer, -2: last indexed image in the buffer (optional, default to -1L) - virtual void image_buffer_image_tiff_get( const std::optional &id, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get Start message in CBOR format - /// - /// - /// Contains metadata for a dataset (e.g., experimental geometry) - /// - virtual void image_buffer_start_cbor_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get status of the image buffers - /// - /// - /// Can be run at any stage of Jungfraujoch operation, including during data collection. The status of the image buffer is volatile during data collection - if data collection goes for more images than available buffer slots, then image might be replaced in the buffer between calling /images and /image.cbor. - /// - virtual void image_buffer_status_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get status of image pusher - /// - /// - /// - /// - virtual void image_pusher_status_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Initialize detector and data acquisition - /// - /// - /// Should be used in two cases: - Detector is in `Inactive` state - Detector is in `Error` state X-ray shutter must be closed. This operation will reconfigure network interface of the detector. During operation of the detector it is recommended to use the `POST /pedestal` operation instead. If storage cells are used, the execution time might be few minutes. This is async function - one needs to use `POST /wait_till_done` to ensure operation is done. - /// - virtual void initialize_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Collect dark current for the detector - /// - /// - /// Updates calibration of the JUNGFRAU detector. Must be in `Idle` state. X-ray shutter must be closed. Recommended to run once per hour for long integration times (> 100 us). This is async function - one needs to use `POST /wait_till_done` to ensure operation is done. - /// - virtual void pedestal_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get pedestal in TIFF format - /// - /// - /// - /// - /// Gain level (0, 1, 2) - /// Storage cell number (optional, default to 0) - virtual void preview_pedestal_tiff_get( const std::optional &gainLevel, const std::optional &sc, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Generate 1D plot from Jungfraujoch and send in raw binary format. Data are provided as (32-bit) float binary array. This format doesn't transmit information about X-axis, only values, so it is of limited use for azimuthal integration. - /// - /// - /// - /// - /// Type of requested plot - /// Name of ROI for which plot is requested (optional, default to "") - virtual void preview_plot_bin_get( const std::optional &type, const std::optional &roi, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Generate 1D plot from Jungfraujoch - /// - /// - /// - /// - /// Type of requested plot - /// Binning of frames for the plot (0 = default binning) (optional, default to 1) - /// Enable DEFLATE compression of output data. (optional, default to false) - /// Fill value for elements that were missed during data collection (optional, default to 0.0f) - /// If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value For still measurement the number is ignored (optional, default to false) - /// Unit used for azim int. (optional, default to "Q_recipA") - virtual void preview_plot_get( const std::optional &type, const std::optional &binning, const std::optional &compression, const std::optional &fill, const std::optional &experimentalCoord, const std::optional &azintUnit, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get full scan result - /// - /// - /// - /// - virtual void result_scan_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Start detector - /// - /// - /// Start data acquisition. Detector must be in `Idle` state. Doesn't run calibration procedure. When the function returns, detector is ready to accept soft/TTL triggers. - /// - /// (optional) - virtual void start_post( const org::openapitools::server::model::Dataset_settings &datasetSettings, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get calibration statistics - /// - /// - /// Statistics are provided for each module/storage cell separately - /// - virtual void statistics_calibration_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get data collection statistics - /// - /// - /// Results of the last data collection - /// - virtual void statistics_data_collection_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get general statistics - /// - /// - /// - /// - /// Enable DEFLATE compression of output data. (optional, default to false) - virtual void statistics_get( const std::optional &compression, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get Jungfraujoch status - /// - /// - /// Status of the data acquisition - /// - virtual void status_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Send soft trigger to the detector - /// - /// - /// Generate soft trigger - /// - virtual void trigger_post( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Get Jungfraujoch version of jfjoch_broker - /// - /// - /// - /// - virtual void version_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Wait for acquisition done - /// - /// - /// Block execution of external script till initialization, data collection or pedestal is finished. Running this command does not affect (cancel) running data collection, it is only to ensure synchronous execution of other software. To not block web server for a indefinite period of time, the procedure is provided with a timeout. Extending timeout is possible, but requires to ensure safety that client will not close the connection and retry the connection. - /// - /// Timeout in seconds (0 == immediate response) (optional, default to 60) - virtual void wait_till_done_post( const std::optional &timeout, Pistache::Http::ResponseWriter &response) = 0; - /// - /// Return XFEL event codes for the current data acquisition - /// - /// - /// Return array of XFEL event codes - /// - virtual void xfel_event_code_get( Pistache::Http::ResponseWriter &response) = 0; - /// - /// Return XFEL pulse IDs for the current data acquisition - /// - /// - /// Return array of XFEL pulse IDs - (-1) if image not recorded - /// - virtual void xfel_pulse_id_get( Pistache::Http::ResponseWriter &response) = 0; - -}; - -} // namespace org::openapitools::server::api - -#endif /* DefaultApi_H_ */ - diff --git a/broker/gen/model/Azim_int_settings.cpp b/broker/gen/model/Azim_int_settings.cpp index c802d4fd..3b7ec7d6 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 d5b78163..ed7a7997 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ee16dd9f..4c786e8d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ebf0dc65..f4fa947d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 5a4e5357..5cb2378d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 121530cf..ee8be6dc 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 84cadeb6..4760f9da 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b6af8567..6658a4ca 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 3d7d04f5..333c962b 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 813ab284..4eb7517f 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 d09a20ef..5eff3b7b 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ade74862..62938379 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 4207fece..685d7716 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 749b80a5..9d2c610c 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 210b5d6a..7dc40656 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 6986b951..63d6f47b 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 979a296a..9a678e55 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b727eb22..89eb3bc9 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8ceb4299..dd25b567 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 a61abf54..5f2e0749 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 041c4e5a..82e0f82e 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 24eb9800..9a6079c0 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 1af14bbf..5b9dd956 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8c97fa84..fa0bae1d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 adb2b595..2e543705 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8bb6eb25..de6b9162 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8e04bb9f..ea23425f 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 5acac557..6514866a 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 06ba3d35..f5fd0d63 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 79235aaf..aeb42ab9 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 68461278..0e2f5480 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 6fcd801c..dbdaa175 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 6fc74199..ad9c18e2 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 d90c21ef..4c0780b5 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 d22d3e5e..456d8b6e 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8cdd1149..f912ce41 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 47388e76..8ba34a5b 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 25e259e9..fe00c45d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 822a0b07..94a00003 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 6477c821..6d8638f6 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2a518c32..cbcb62de 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 fcf027a2..5bbf5688 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 4c9783ba..59592c61 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 0b1317e2..da6398cb 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 e5714fd3..675bc16a 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 607688a7..618ec403 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2feb9d92..09f47f48 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 be13f425..da540034 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 65fd1ce5..a9f2b111 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 08174bbf..acf3e31b 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 6144b84a..507a1ab3 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 e540d5f8..861354bb 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b7fa6620..d74bf3a6 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 957f4678..5102cc86 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 10325f69..5b8cb200 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 c14f66fe..67620828 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 57f05ae5..9a714f1c 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 3db6fe80..e9036f99 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 c8a30fbc..0c576789 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2d7ff32d..7de35312 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 c27c2a7c..50aa713d 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 4b9b3c6c..0a83f2a0 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 eb1ca75e..4b2fbfc8 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 35a5567e..96533e79 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 bd515625..c7f1a943 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). @@ -39,7 +39,6 @@ Jfjoch_settings::Jfjoch_settings() m_Numa_policy = ""; m_Numa_policyIsSet = false; m_Frontend_directory = ""; - m_SslIsSet = false; m_Spot_findingIsSet = false; m_Zeromq_previewIsSet = false; m_Zeromq_metadataIsSet = false; @@ -141,7 +140,7 @@ bool Jfjoch_settings::validate(std::stringstream& msg, const std::string& pathPr } } - + return success; } @@ -196,9 +195,6 @@ bool Jfjoch_settings::operator==(const Jfjoch_settings& rhs) const && - ((!sslIsSet() && !rhs.sslIsSet()) || (sslIsSet() && rhs.sslIsSet() && getSsl() == rhs.getSsl())) && - - ((!spotFindingIsSet() && !rhs.spotFindingIsSet()) || (spotFindingIsSet() && rhs.spotFindingIsSet() && getSpotFinding() == rhs.getSpotFinding())) && (getImagePusher() == rhs.getImagePusher()) @@ -252,8 +248,6 @@ void to_json(nlohmann::json& j, const Jfjoch_settings& o) if(o.numaPolicyIsSet()) j["numa_policy"] = o.m_Numa_policy; j["frontend_directory"] = o.m_Frontend_directory; - if(o.sslIsSet()) - j["ssl"] = o.m_Ssl; if(o.spotFindingIsSet()) j["spot_finding"] = o.m_Spot_finding; j["image_pusher"] = o.m_Image_pusher; @@ -335,11 +329,6 @@ void from_json(const nlohmann::json& j, Jfjoch_settings& o) o.m_Numa_policyIsSet = true; } j.at("frontend_directory").get_to(o.m_Frontend_directory); - if(j.find("ssl") != j.end()) - { - j.at("ssl").get_to(o.m_Ssl); - o.m_SslIsSet = true; - } if(j.find("spot_finding") != j.end()) { j.at("spot_finding").get_to(o.m_Spot_finding); @@ -601,23 +590,6 @@ void Jfjoch_settings::setFrontendDirectory(std::string const& value) { m_Frontend_directory = value; } -org::openapitools::server::model::Jfjoch_settings_ssl Jfjoch_settings::getSsl() const -{ - return m_Ssl; -} -void Jfjoch_settings::setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value) -{ - m_Ssl = value; - m_SslIsSet = true; -} -bool Jfjoch_settings::sslIsSet() const -{ - return m_SslIsSet; -} -void Jfjoch_settings::unsetSsl() -{ - m_SslIsSet = false; -} org::openapitools::server::model::Spot_finding_settings Jfjoch_settings::getSpotFinding() const { return m_Spot_finding; diff --git a/broker/gen/model/Jfjoch_settings.h b/broker/gen/model/Jfjoch_settings.h index ac25223d..99f5aabe 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * Contact: filip.leonarski@psi.ch * * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). @@ -36,7 +36,6 @@ #include "Image_pusher_type.h" #include "Zeromq_settings.h" #include "Instrument_metadata.h" -#include "Jfjoch_settings_ssl.h" #include namespace org::openapitools::server::model @@ -179,13 +178,6 @@ public: /// /// /// - org::openapitools::server::model::Jfjoch_settings_ssl getSsl() const; - void setSsl(org::openapitools::server::model::Jfjoch_settings_ssl const& value); - bool sslIsSet() const; - void unsetSsl(); - /// - /// - /// org::openapitools::server::model::Spot_finding_settings getSpotFinding() const; void setSpotFinding(org::openapitools::server::model::Spot_finding_settings const& value); bool spotFindingIsSet() const; @@ -250,8 +242,6 @@ protected: bool m_Numa_policyIsSet; std::string m_Frontend_directory; - org::openapitools::server::model::Jfjoch_settings_ssl m_Ssl; - bool m_SslIsSet; org::openapitools::server::model::Spot_finding_settings m_Spot_finding; bool m_Spot_findingIsSet; org::openapitools::server::model::Image_pusher_type m_Image_pusher; diff --git a/broker/gen/model/Jfjoch_settings_ssl.cpp b/broker/gen/model/Jfjoch_settings_ssl.cpp index 5a9bf1e2..fdb29d22 100644 --- a/broker/gen/model/Jfjoch_settings_ssl.cpp +++ b/broker/gen/model/Jfjoch_settings_ssl.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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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_ssl.h b/broker/gen/model/Jfjoch_settings_ssl.h index 74b7a658..c32d2134 100644 --- a/broker/gen/model/Jfjoch_settings_ssl.h +++ b/broker/gen/model/Jfjoch_settings_ssl.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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8be845b0..3faebae4 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 c0226338..4e4af5f6 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 5eef8084..90e17070 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ffbd987a..b3dd5b6f 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 752e1320..5bf8e143 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 9a48467e..13e6758f 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 90e50385..218aec27 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b7a7c492..8c4684a8 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 5a288c8e..6aa8ab13 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ad644cc4..a2f6a414 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 777de69b..b1519e1a 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 8f99325f..17aae345 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 df07b118..97313b80 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 f27b3494..bd0cfec2 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 a197ca77..f47c43ef 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 dc9e1bd7..a5ec7af1 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 9807b6e6..14117cef 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 7ad84a65..9d6eb755 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2102b9ae..f4a0dacd 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 4b3b7f18..3f0a9072 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 3428f9af..9cf7f5c1 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 baf8b15d..79b259e2 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 09d41705..70a86d55 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 150cc54d..d16c0b6c 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 67a139ab..6596e667 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 35d34b5e..766e6907 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 4e9cbdad..96fa8791 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 51df9df7..3fb51bb5 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b5bba775..d8f01b42 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2f4817c3..e47bbdcc 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 ccc25aa9..44810d82 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 5c905891..958459b4 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 e8ba423a..9e53547e 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 f70ecf5e..662d6613 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 c9b43933..d3b5a5be 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 9a3f5287..a5ddb029 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 2d11f7b2..3f6a1ccd 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 91593a55..ec3013d3 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 bf5e0769..65d0dc50 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 a4900ae2..4773efd8 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 274800d0..6865660e 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b8820700..e3058923 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 71cfd3de..5f271a08 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 458a0eb9..a81dea5e 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 71223f97..060d4388 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 a6e40498..31cf6c08 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 b905f5d6..ede725b3 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 858659d2..86ff9f53 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.132 +* The version of the OpenAPI document: 1.0.0-rc.133 * 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 67c0d2f1..86ba0e1f 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.132 + version: 1.0.0-rc.133 contact: name: Filip Leonarski (Paul Scherrer Institute) email: filip.leonarski@psi.ch @@ -42,14 +42,6 @@ components: default: 1 type: integer description: Binning of frames for the plot (0 = default binning) - compression: - in: query - name: compression - required: false - schema: - type: boolean - default: false - description: Enable DEFLATE compression of output data. experimental_coord: in: query name: experimental_coord @@ -99,7 +91,6 @@ components: - spot_count_indexed - spot_count_ice - indexing_rate - - indexing_time - indexing_unit_cell_length - indexing_unit_cell_angle - profile_radius @@ -2249,20 +2240,6 @@ components: frontend_directory: type: string description: Location of built JavaScript web frontend - ssl: - type: object - required: - - certificate - - key - properties: - certificate: - type: string - minLength: 1 - example: "server.crt" - key: - type: string - minLength: 1 - example: "server.key" spot_finding: $ref: '#/components/schemas/spot_finding_settings' image_pusher: @@ -3082,8 +3059,6 @@ paths: /statistics: get: summary: Get general statistics - parameters: - - $ref: '#/components/parameters/compression' responses: "200": description: Everything OK @@ -3163,6 +3138,8 @@ paths: responses: "200": description: All good + "400": + description: Mask is not 4-byte unsigned integer array or empty body "500": description: Error within Jungfraujoch code - see output message. content: @@ -3247,6 +3224,8 @@ paths: schema: type: string format: binary + "400": + description: Invalid gain level or storage cell number "404": description: No calibration recorded so far /preview/plot: @@ -3254,7 +3233,6 @@ paths: summary: Generate 1D plot from Jungfraujoch parameters: - $ref: "#/components/parameters/binning" - - $ref: "#/components/parameters/compression" - $ref: "#/components/parameters/plot_type" - $ref: "#/components/parameters/fill_value" - $ref: "#/components/parameters/experimental_coord" diff --git a/broker/jfjoch_broker.cpp b/broker/jfjoch_broker.cpp index 90d84809..dde40cbe 100644 --- a/broker/jfjoch_broker.cpp +++ b/broker/jfjoch_broker.cpp @@ -2,33 +2,35 @@ // SPDX-License-Identifier: GPL-3.0-only // Using OpenAPI licensed with Apache License 2.0 -#include #include #include +#include +#include + #include #include "../common/Logger.h" - -#include "JFJochBrokerHttp.h" - -#include "JFJochBrokerParser.h" -#include "../writer/HDF5Objects.h" #include "../common/print_license.h" #include "../detector_control/DectrisSimplonClient.h" +#include "../writer/HDF5Objects.h" -static Pistache::Http::Endpoint *httpEndpoint; +#include "JFJochBrokerHttp.h" +#include "JFJochBrokerParser.h" -static void sigHandler [[noreturn]] (int sig){ - switch(sig){ +static httplib::Server *httpServer = nullptr; + +static void sigHandler [[noreturn]] (int sig) { + switch (sig) { case SIGINT: case SIGQUIT: case SIGTERM: case SIGHUP: default: - httpEndpoint->shutdown(); + if (httpServer) + httpServer->stop(); break; } - exit(0); + std::exit(0); } static void setUpUnixSignals(std::vector quitSignals) { @@ -39,30 +41,28 @@ static void setUpUnixSignals(std::vector quitSignals) { struct sigaction sa; sa.sa_handler = sigHandler; - sa.sa_mask = blocking_mask; - sa.sa_flags = 0; + sa.sa_mask = blocking_mask; + sa.sa_flags = 0; for (auto sig : quitSignals) sigaction(sig, &sa, nullptr); } -int main (int argc, char **argv) { +int main(int argc, char **argv) { RegisterHDF5Filter(); - print_license("jfjoch_broker"); if ((argc == 1) || (argc > 3)) { std::cout << "Usage ./jfjoch_broker {}" << std::endl; - exit(EXIT_FAILURE); + return EXIT_FAILURE; } uint16_t http_port = 5232; - if (argc >= 3) http_port = atoi(argv[2]); + if (argc >= 3) http_port = static_cast(std::atoi(argv[2])); Logger logger("jfjoch_broker"); org::openapitools::server::model::Jfjoch_settings settings; - std::ifstream file(argv[1]); try { nlohmann::json input = nlohmann::json::parse(file); @@ -71,7 +71,7 @@ int main (int argc, char **argv) { logger.Info("JSON configuration file read properly"); } catch (const std::exception &e) { logger.Error("Error reading JSON configuration file: " + std::string(e.what())); - exit(EXIT_FAILURE); + return EXIT_FAILURE; } if (settings.verboseIsSet() && settings.isVerbose()) @@ -80,7 +80,6 @@ int main (int argc, char **argv) { logger.Verbose(false); std::unique_ptr image_pusher = ParseImagePusher(settings); - if (image_pusher) logger.Info(image_pusher->PrintSetup()); @@ -90,7 +89,7 @@ int main (int argc, char **argv) { if (det_setup.empty()) { logger.Error("At least one detector need to be defined in the config file"); - exit(EXIT_FAILURE); + return EXIT_FAILURE; } DiffractionExperiment experiment(det_setup[0]); @@ -100,36 +99,14 @@ int main (int argc, char **argv) { AcquisitionDeviceGroup aq_devices; ParseAcquisitionDeviceGroup(settings, aq_devices); - experiment.DataStreams(aq_devices.size()); int32_t send_buffer_size_MiB = settings.getImageBufferMiB(); - std::unique_ptr receiver - = std::make_unique(aq_devices, logger, *image_pusher, send_buffer_size_MiB); + std::unique_ptr receiver = + std::make_unique(aq_devices, logger, *image_pusher, send_buffer_size_MiB); ParseReceiverSettings(settings, *receiver); - Pistache::Address addr(Pistache::Ipv4::any(), Pistache::Port(http_port)); - - httpEndpoint = new Pistache::Http::Endpoint((addr)); - - auto router = std::make_shared(); - - auto opts = Pistache::Http::Endpoint::options().threads(8).maxRequestSize(64*1024*1024); - opts.flags(Pistache::Tcp::Options::ReuseAddr); - - httpEndpoint->init(opts); - - if (settings.sslIsSet()) { - auto ssl = settings.getSsl(); - httpEndpoint->useSSL(ssl.getCertificate(), ssl.getKey(), true); - // We allow compression. While this introduces certain vulnerabilities, but risk is so small we ignore this. - } - - signal(SIGPIPE, SIG_IGN); - std::vector sigs{SIGQUIT, SIGINT, SIGTERM, SIGHUP}; - setUpUnixSignals(sigs); - - JFJochBrokerHttp broker(experiment, spot_finding_settings, router); + JFJochBrokerHttp broker(experiment, spot_finding_settings); broker.FrontendDirectory(settings.getFrontendDirectory()); for (const auto &d: det_setup) @@ -138,8 +115,25 @@ int main (int argc, char **argv) { if (receiver) broker.Services().Receiver(receiver.get()); - httpEndpoint->setHandler(router->handler()); - httpEndpoint->serve(); + httplib::Server server; + httpServer = &server; - httpEndpoint->shutdown(); -} \ No newline at end of file + server.Get("/", [](const httplib::Request &req, httplib::Response &res) { + res.status = 302; // Found (temporary redirect) + res.set_header("Location", "/frontend"); + }); + server.set_mount_point("/frontend", settings.getFrontendDirectory()); + + signal(SIGPIPE, SIG_IGN); + std::vector sigs{SIGQUIT, SIGINT, SIGTERM, SIGHUP}; + setUpUnixSignals(sigs); + + broker.attach(server); + + if (!server.listen("0.0.0.0", http_port)) { + logger.Error("Failed to start HTTP server"); + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/broker/redoc-static.html b/broker/redoc-static.html index 9f99b400..765681ec 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.132)

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.133)

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 @@ -790,8 +790,7 @@ This can only be done when detector is Idle, Error or

Request samples

Content type
application/json
{
  • "box": {
    },
  • "circle": {
    },
  • "azim": {
    }
}

Response samples

Content type
application/json
{
  • "msg": "Detector in wrong state",
  • "reason": "WrongDAQState"
}

Get general statistics

query Parameters
compression
boolean
Default: false

Enable DEFLATE compression of output data.

-

Responses

Request samples

Content type
application/json
{
  • "box": {
    },
  • "circle": {
    },
  • "azim": {
    }
}

Response samples

Content type
application/json
{
  • "msg": "Detector in wrong state",
  • "reason": "WrongDAQState"
}

Get general statistics

Responses

Response samples

Content type
application/json
{
  • "detector": {
    },
  • "detector_list": {
    },
  • "detector_settings": {
    },
  • "image_format_settings": {
    },
  • "instrument_metadata": {
    },
  • "file_writer_settings": {
    },
  • "data_processing_settings": {
    },
  • "measurement": {
    },
  • "broker": {
    },
  • "fpga": [
    ],
  • "calibration": [
    ],
  • "zeromq_preview": {
    },
  • "zeromq_metadata": {
    },
  • "dark_mask": {
    },
  • "pixel_mask": {
    },
  • "roi": {
    },
  • "az_int": {
    },
  • "buffer": {
    },
  • "indexing": {
    },
  • "image_pusher": {
    }
}

Get data collection statistics

Results of the last data collection

Responses

Request Body schema: application/octet-stream
string <binary>

Responses

Response samples

Content type
application/json
{
  • "msg": "Detector in wrong state",
  • "reason": "WrongDAQState"
}

Get mask of the detector (TIFF)

Should be in Idle state. @@ -844,11 +844,11 @@ User mask is not automatically applied - i.e. pixels with user mask will have a

http://localhost:5232/config/user_mask.tiff

Response samples

Content type
application/json
{
  • "msg": "Detector in wrong state",
  • "reason": "WrongDAQState"
}

Get pedestal in TIFF format

query Parameters
gain_level
required
integer

Gain level (0, 1, 2)

sc
integer

Storage cell number

Responses

Generate 1D plot from Jungfraujoch

query Parameters
binning
integer
Default: 1

Binning of frames for the plot (0 = default binning)

-
compression
boolean
Default: false

Enable DEFLATE compression of output data.

-
type
required
string
Enum: "bkg_estimate" "azint" "azint_1d" "spot_count" "spot_count_low_res" "spot_count_indexed" "spot_count_ice" "indexing_rate" "indexing_time" "indexing_unit_cell_length" "indexing_unit_cell_angle" "profile_radius" "mosaicity" "b_factor" "error_pixels" "saturated_pixels" "image_collection_efficiency" "receiver_delay" "receiver_free_send_buf" "strong_pixels" "roi_sum" "roi_mean" "roi_max_count" "roi_pixels" "roi_weighted_x" "roi_weighted_y" "packets_received" "max_pixel_value" "resolution_estimate" "pixel_sum" "processing_time" "beam_center_x" "beam_center_y"

Type of requested plot

+
type
required
string
Enum: "bkg_estimate" "azint" "azint_1d" "spot_count" "spot_count_low_res" "spot_count_indexed" "spot_count_ice" "indexing_rate" "indexing_unit_cell_length" "indexing_unit_cell_angle" "profile_radius" "mosaicity" "b_factor" "error_pixels" "saturated_pixels" "image_collection_efficiency" "receiver_delay" "receiver_free_send_buf" "strong_pixels" "roi_sum" "roi_mean" "roi_max_count" "roi_pixels" "roi_weighted_x" "roi_weighted_y" "packets_received" "max_pixel_value" "resolution_estimate" "pixel_sum" "processing_time" "beam_center_x" "beam_center_y"

Type of requested plot

fill
number <float>

Fill value for elements that were missed during data collection

experimental_coord
boolean
Default: false

If measurement has goniometer axis defined, plot X-axis will represent rotation angle If measurement has grid scan defined, plot X-axis and Y-axis will represent grid position, Z will be used as the final value @@ -860,7 +860,7 @@ For still measurement the number is ignored

http://localhost:5232/preview/plot

Response samples

Content type
application/json
{
  • "title": "string",
  • "unit_x": "image_number",
  • "size_x": 0.1,
  • "size_y": 0.1,
  • "plot": [
    ]
}

Generate 1D plot from Jungfraujoch and send in raw binary format. Data are provided as (32-bit) float binary array. This format doesn't transmit information about X-axis, only values, so it is of limited use for azimuthal integration. -

query Parameters
type
required
string
Enum: "bkg_estimate" "azint" "azint_1d" "spot_count" "spot_count_low_res" "spot_count_indexed" "spot_count_ice" "indexing_rate" "indexing_time" "indexing_unit_cell_length" "indexing_unit_cell_angle" "profile_radius" "mosaicity" "b_factor" "error_pixels" "saturated_pixels" "image_collection_efficiency" "receiver_delay" "receiver_free_send_buf" "strong_pixels" "roi_sum" "roi_mean" "roi_max_count" "roi_pixels" "roi_weighted_x" "roi_weighted_y" "packets_received" "max_pixel_value" "resolution_estimate" "pixel_sum" "processing_time" "beam_center_x" "beam_center_y"

Type of requested plot

+
query Parameters
type
required
string
Enum: "bkg_estimate" "azint" "azint_1d" "spot_count" "spot_count_low_res" "spot_count_indexed" "spot_count_ice" "indexing_rate" "indexing_unit_cell_length" "indexing_unit_cell_angle" "profile_radius" "mosaicity" "b_factor" "error_pixels" "saturated_pixels" "image_collection_efficiency" "receiver_delay" "receiver_free_send_buf" "strong_pixels" "roi_sum" "roi_mean" "roi_max_count" "roi_pixels" "roi_weighted_x" "roi_weighted_y" "packets_received" "max_pixel_value" "resolution_estimate" "pixel_sum" "processing_time" "beam_center_x" "beam_center_y"

Type of requested plot

roi
string non-empty

Name of ROI for which plot is requested

Responses