power-grid-model 1.11.48__py3-none-win_amd64.whl → 1.12.72__py3-none-win_amd64.whl

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/meta_data.hpp

@@ -1,84 +1,84 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-#ifndef POWER_GRID_MODEL_CPP_META_DATA_HPP
-#define POWER_GRID_MODEL_CPP_META_DATA_HPP
-
-#include "basics.hpp"
-#include "handle.hpp"
-
-#include "power_grid_model_c/meta_data.h"
-
-namespace power_grid_model_cpp {
-class MetaData {
-  public:
-    static Idx n_datasets() { return PGM_meta_n_datasets(nullptr); }
-
-    static MetaDataset const* get_dataset_by_idx(Idx idx) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_dataset_by_idx, idx);
-    }
-
-    static MetaDataset const* get_dataset_by_name(std::string const& dataset) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_dataset_by_name, dataset.c_str());
-    }
-
-    static std::string dataset_name(MetaDataset const* dataset) {
-        return std::string{PGM_meta_dataset_name(nullptr, dataset)};
-    }
-
-    static Idx n_components(MetaDataset const* dataset) { return PGM_meta_n_components(nullptr, dataset); }
-
-    static MetaComponent const* get_component_by_idx(MetaDataset const* dataset, Idx idx) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_component_by_idx, dataset, idx);
-    }
-
-    static MetaComponent const* get_component_by_name(std::string const& dataset, std::string const& component) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_component_by_name, dataset.c_str(), component.c_str());
-    }
-
-    static std::string component_name(MetaComponent const* component) {
-        return std::string{PGM_meta_component_name(nullptr, component)};
-    }
-
-    static size_t component_size(MetaComponent const* component) { return PGM_meta_component_size(nullptr, component); }
-
-    static size_t component_alignment(MetaComponent const* component) {
-        return PGM_meta_component_alignment(nullptr, component);
-    }
-
-    static Idx n_attributes(MetaComponent const* component) { return PGM_meta_n_attributes(nullptr, component); }
-
-    static MetaAttribute const* get_attribute_by_idx(MetaComponent const* component, Idx idx) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_attribute_by_idx, component, idx);
-    }
-
-    static MetaAttribute const* get_attribute_by_name(std::string const& dataset, std::string const& component,
-                                                      std::string const& attribute) {
-        Handle const handle{};
-        return handle.call_with(PGM_meta_get_attribute_by_name, dataset.c_str(), component.c_str(), attribute.c_str());
-    }
-
-    static std::string attribute_name(MetaAttribute const* attribute) {
-        return std::string{PGM_meta_attribute_name(nullptr, attribute)};
-    }
-
-    static PGM_CType attribute_ctype(MetaAttribute const* attribute) {
-        return static_cast<PGM_CType>(PGM_meta_attribute_ctype(nullptr, attribute));
-    }
-
-    static size_t attribute_offset(MetaAttribute const* attribute) {
-        return PGM_meta_attribute_offset(nullptr, attribute);
-    }
-
-    static int is_little_endian() { return PGM_is_little_endian(nullptr); }
-};
-} // namespace power_grid_model_cpp
-
-#endif // POWER_GRID_MODEL_CPP_META_DATA_HPP
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_META_DATA_HPP
+#define POWER_GRID_MODEL_CPP_META_DATA_HPP
+
+#include "basics.hpp"
+#include "handle.hpp"
+
+#include "power_grid_model_c/meta_data.h"
+
+namespace power_grid_model_cpp {
+class MetaData {
+  public:
+    static Idx n_datasets() { return PGM_meta_n_datasets(nullptr); }
+
+    static MetaDataset const* get_dataset_by_idx(Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_dataset_by_idx, idx);
+    }
+
+    static MetaDataset const* get_dataset_by_name(std::string const& dataset) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_dataset_by_name, dataset.c_str());
+    }
+
+    static std::string dataset_name(MetaDataset const* dataset) {
+        return std::string{PGM_meta_dataset_name(nullptr, dataset)};
+    }
+
+    static Idx n_components(MetaDataset const* dataset) { return PGM_meta_n_components(nullptr, dataset); }
+
+    static MetaComponent const* get_component_by_idx(MetaDataset const* dataset, Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_component_by_idx, dataset, idx);
+    }
+
+    static MetaComponent const* get_component_by_name(std::string const& dataset, std::string const& component) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_component_by_name, dataset.c_str(), component.c_str());
+    }
+
+    static std::string component_name(MetaComponent const* component) {
+        return std::string{PGM_meta_component_name(nullptr, component)};
+    }
+
+    static size_t component_size(MetaComponent const* component) { return PGM_meta_component_size(nullptr, component); }
+
+    static size_t component_alignment(MetaComponent const* component) {
+        return PGM_meta_component_alignment(nullptr, component);
+    }
+
+    static Idx n_attributes(MetaComponent const* component) { return PGM_meta_n_attributes(nullptr, component); }
+
+    static MetaAttribute const* get_attribute_by_idx(MetaComponent const* component, Idx idx) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_attribute_by_idx, component, idx);
+    }
+
+    static MetaAttribute const* get_attribute_by_name(std::string const& dataset, std::string const& component,
+                                                      std::string const& attribute) {
+        Handle const handle{};
+        return handle.call_with(PGM_meta_get_attribute_by_name, dataset.c_str(), component.c_str(), attribute.c_str());
+    }
+
+    static std::string attribute_name(MetaAttribute const* attribute) {
+        return std::string{PGM_meta_attribute_name(nullptr, attribute)};
+    }
+
+    static PGM_CType attribute_ctype(MetaAttribute const* attribute) {
+        return static_cast<PGM_CType>(PGM_meta_attribute_ctype(nullptr, attribute));
+    }
+
+    static size_t attribute_offset(MetaAttribute const* attribute) {
+        return PGM_meta_attribute_offset(nullptr, attribute);
+    }
+
+    static int is_little_endian() { return PGM_is_little_endian(nullptr); }
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_META_DATA_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/model.hpp

@@ -1,63 +1,63 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-#ifndef POWER_GRID_MODEL_CPP_MODEL_HPP
-#define POWER_GRID_MODEL_CPP_MODEL_HPP
-
-#include "basics.hpp"
-#include "dataset.hpp"
-#include "handle.hpp"
-#include "options.hpp"
-
-#include "power_grid_model_c/model.h"
-
-namespace power_grid_model_cpp {
-class Model {
-  public:
-    Model(double system_frequency, DatasetConst const& input_dataset)
-        : model_{handle_.call_with(PGM_create_model, system_frequency, input_dataset.get())} {}
-    Model(Model const& other) : model_{handle_.call_with(PGM_copy_model, other.get())} {}
-    Model& operator=(Model const& other) {
-        if (this != &other) {
-            model_.reset(handle_.call_with(PGM_copy_model, other.get()));
-        }
-        return *this;
-    }
-    Model(Model&& other) noexcept : handle_{std::move(other.handle_)}, model_{std::move(other.model_)} {}
-    Model& operator=(Model&& other) noexcept {
-        if (this != &other) {
-            handle_ = std::move(other.handle_);
-            model_ = std::move(other.model_);
-        }
-        return *this;
-    }
-    ~Model() = default;
-
-    PowerGridModel const* get() const { return model_.get(); }
-    PowerGridModel* get() { return model_.get(); }
-
-    void update(DatasetConst const& update_dataset) {
-        handle_.call_with(PGM_update_model, get(), update_dataset.get());
-    }
-
-    void get_indexer(std::string const& component, Idx size, ID const* ids, Idx* indexer) const {
-        handle_.call_with(PGM_get_indexer, get(), component.c_str(), size, ids, indexer);
-    }
-
-    void calculate(Options const& opt, DatasetMutable const& output_dataset, DatasetConst const& batch_dataset) {
-        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), batch_dataset.get());
-    }
-
-    void calculate(Options const& opt, DatasetMutable const& output_dataset) {
-        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), nullptr);
-    }
-
-  private:
-    Handle handle_{};
-    detail::UniquePtr<PowerGridModel, &PGM_destroy_model> model_;
-};
-} // namespace power_grid_model_cpp
-
-#endif // POWER_GRID_MODEL_CPP_MODEL_HPP
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_MODEL_HPP
+#define POWER_GRID_MODEL_CPP_MODEL_HPP
+
+#include "basics.hpp"
+#include "dataset.hpp"
+#include "handle.hpp"
+#include "options.hpp"
+
+#include "power_grid_model_c/model.h"
+
+namespace power_grid_model_cpp {
+class Model {
+  public:
+    Model(double system_frequency, DatasetConst const& input_dataset)
+        : model_{handle_.call_with(PGM_create_model, system_frequency, input_dataset.get())} {}
+    Model(Model const& other) : model_{handle_.call_with(PGM_copy_model, other.get())} {}
+    Model& operator=(Model const& other) {
+        if (this != &other) {
+            model_.reset(handle_.call_with(PGM_copy_model, other.get()));
+        }
+        return *this;
+    }
+    Model(Model&& other) noexcept : handle_{std::move(other.handle_)}, model_{std::move(other.model_)} {}
+    Model& operator=(Model&& other) noexcept {
+        if (this != &other) {
+            handle_ = std::move(other.handle_);
+            model_ = std::move(other.model_);
+        }
+        return *this;
+    }
+    ~Model() = default;
+
+    PowerGridModel const* get() const { return model_.get(); }
+    PowerGridModel* get() { return model_.get(); }
+
+    void update(DatasetConst const& update_dataset) {
+        handle_.call_with(PGM_update_model, get(), update_dataset.get());
+    }
+
+    void get_indexer(std::string const& component, Idx size, ID const* ids, Idx* indexer) const {
+        handle_.call_with(PGM_get_indexer, get(), component.c_str(), size, ids, indexer);
+    }
+
+    void calculate(Options const& opt, DatasetMutable const& output_dataset, DatasetConst const& batch_dataset) {
+        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), batch_dataset.get());
+    }
+
+    void calculate(Options const& opt, DatasetMutable const& output_dataset) {
+        handle_.call_with(PGM_calculate, get(), opt.get(), output_dataset.get(), nullptr);
+    }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<PowerGridModel, &PGM_destroy_model> model_;
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_MODEL_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/options.hpp

@@ -1,52 +1,52 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-#ifndef POWER_GRID_MODEL_CPP_OPTIONS_HPP
-#define POWER_GRID_MODEL_CPP_OPTIONS_HPP
-
-#include "basics.hpp"
-#include "handle.hpp"
-
-#include "power_grid_model_c/options.h"
-
-namespace power_grid_model_cpp {
-class Options {
-  public:
-    Options() : options_{handle_.call_with(PGM_create_options)} {}
-
-    RawOptions* get() { return options_.get(); }
-    RawOptions const* get() const { return options_.get(); }
-
-    void set_calculation_type(Idx type) { handle_.call_with(PGM_set_calculation_type, get(), type); }
-
-    void set_calculation_method(Idx method) { handle_.call_with(PGM_set_calculation_method, get(), method); }
-
-    void set_symmetric(Idx sym) { handle_.call_with(PGM_set_symmetric, get(), sym); }
-
-    void set_err_tol(double err_tol) { handle_.call_with(PGM_set_err_tol, get(), err_tol); }
-
-    void set_max_iter(Idx max_iter) { handle_.call_with(PGM_set_max_iter, get(), max_iter); }
-
-    void set_threading(Idx threading) { handle_.call_with(PGM_set_threading, get(), threading); }
-
-    void set_short_circuit_voltage_scaling(Idx short_circuit_voltage_scaling) {
-        handle_.call_with(PGM_set_short_circuit_voltage_scaling, get(), short_circuit_voltage_scaling);
-    }
-
-    void set_tap_changing_strategy(Idx tap_changing_strategy) {
-        handle_.call_with(PGM_set_tap_changing_strategy, get(), tap_changing_strategy);
-    }
-
-    void set_experimental_features(Idx experimental_features) {
-        handle_.call_with(PGM_set_experimental_features, get(), experimental_features);
-    }
-
-  private:
-    Handle handle_{};
-    detail::UniquePtr<RawOptions, &PGM_destroy_options> options_;
-};
-} // namespace power_grid_model_cpp
-
-#endif // POWER_GRID_MODEL_CPP_OPTIONS_HPP
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_OPTIONS_HPP
+#define POWER_GRID_MODEL_CPP_OPTIONS_HPP
+
+#include "basics.hpp"
+#include "handle.hpp"
+
+#include "power_grid_model_c/options.h"
+
+namespace power_grid_model_cpp {
+class Options {
+  public:
+    Options() : options_{handle_.call_with(PGM_create_options)} {}
+
+    RawOptions* get() { return options_.get(); }
+    RawOptions const* get() const { return options_.get(); }
+
+    void set_calculation_type(Idx type) { handle_.call_with(PGM_set_calculation_type, get(), type); }
+
+    void set_calculation_method(Idx method) { handle_.call_with(PGM_set_calculation_method, get(), method); }
+
+    void set_symmetric(Idx sym) { handle_.call_with(PGM_set_symmetric, get(), sym); }
+
+    void set_err_tol(double err_tol) { handle_.call_with(PGM_set_err_tol, get(), err_tol); }
+
+    void set_max_iter(Idx max_iter) { handle_.call_with(PGM_set_max_iter, get(), max_iter); }
+
+    void set_threading(Idx threading) { handle_.call_with(PGM_set_threading, get(), threading); }
+
+    void set_short_circuit_voltage_scaling(Idx short_circuit_voltage_scaling) {
+        handle_.call_with(PGM_set_short_circuit_voltage_scaling, get(), short_circuit_voltage_scaling);
+    }
+
+    void set_tap_changing_strategy(Idx tap_changing_strategy) {
+        handle_.call_with(PGM_set_tap_changing_strategy, get(), tap_changing_strategy);
+    }
+
+    void set_experimental_features(Idx experimental_features) {
+        handle_.call_with(PGM_set_experimental_features, get(), experimental_features);
+    }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<RawOptions, &PGM_destroy_options> options_;
+};
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_OPTIONS_HPP

power_grid_model/_core/power_grid_model_c/include/power_grid_model_cpp/serialization.hpp

@@ -1,124 +1,124 @@
-// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
-//
-// SPDX-License-Identifier: MPL-2.0
-
-#pragma once
-#ifndef POWER_GRID_MODEL_CPP_SERIALIZATION_HPP
-#define POWER_GRID_MODEL_CPP_SERIALIZATION_HPP
-
-#include "basics.hpp"
-#include "dataset.hpp"
-#include "handle.hpp"
-#include "meta_data.hpp"
-
-#include "power_grid_model_c/serialization.h"
-
-#include <cstring>
-
-namespace power_grid_model_cpp {
-class Deserializer {
-  public:
-    Deserializer(std::vector<std::byte> const& data, Idx serialization_format)
-        : deserializer_{handle_.call_with(PGM_create_deserializer_from_binary_buffer,
-                                          reinterpret_cast<const char*>(data.data()), static_cast<Idx>(data.size()),
-                                          serialization_format)},
-          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
-    Deserializer(std::vector<char> const& data, Idx serialization_format)
-        : deserializer_{handle_.call_with(PGM_create_deserializer_from_binary_buffer, data.data(),
-                                          static_cast<Idx>(data.size()), serialization_format)},
-          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
-    Deserializer(std::string const& data_string, Idx serialization_format)
-        : deserializer_{handle_.call_with(PGM_create_deserializer_from_null_terminated_string, data_string.c_str(),
-                                          serialization_format)},
-          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
-
-    RawDeserializer* get() { return deserializer_.get(); }
-    RawDeserializer const* get() const { return deserializer_.get(); }
-
-    DatasetWritable& get_dataset() { return dataset_; }
-
-    void parse_to_buffer() { handle_.call_with(PGM_deserializer_parse_to_buffer, get()); }
-
-  private:
-    Handle handle_{};
-    detail::UniquePtr<RawDeserializer, &PGM_destroy_deserializer> deserializer_;
-    DatasetWritable dataset_;
-};
-
-class Serializer {
-  public:
-    Serializer(DatasetConst const& dataset, Idx serialization_format)
-        : serializer_{handle_.call_with(PGM_create_serializer, dataset.get(), serialization_format)} {}
-
-    RawSerializer* get() { return serializer_.get(); }
-    RawSerializer const* get() const { return serializer_.get(); }
-
-    std::string_view get_to_binary_buffer(Idx use_compact_list) {
-        char const* temp_data{};
-        Idx buffer_size{};
-        handle_.call_with(PGM_serializer_get_to_binary_buffer, get(), use_compact_list, &temp_data, &buffer_size);
-        if (temp_data == nullptr) {
-            return std::string_view{};
-        } // empty data
-        return std::string_view{temp_data, static_cast<size_t>(buffer_size)};
-    }
-
-    void get_to_binary_buffer(Idx use_compact_list, std::vector<std::byte>& data) {
-        auto temp_data = get_to_binary_buffer(use_compact_list);
-        if (!temp_data.empty()) {
-            data.resize(temp_data.size());
-            std::memcpy(data.data(), temp_data.data(), temp_data.size());
-        } else {
-            data.resize(0); // empty data
-        }
-    }
-
-    void get_to_binary_buffer(Idx use_compact_list, std::vector<char>& data) {
-        auto temp_data = get_to_binary_buffer(use_compact_list);
-        if (!temp_data.empty()) {
-            data.assign(temp_data.begin(), temp_data.end());
-        } else {
-            data.resize(0); // empty data
-        }
-    }
-
-    std::string get_to_zero_terminated_string(Idx use_compact_list, Idx indent) {
-        return std::string{
-            handle_.call_with(PGM_serializer_get_to_zero_terminated_string, get(), use_compact_list, indent)};
-    }
-
-  private:
-    power_grid_model_cpp::Handle handle_{};
-    detail::UniquePtr<RawSerializer, &PGM_destroy_serializer> serializer_;
-};
-
-inline OwningDataset create_owning_dataset(DatasetWritable& writable_dataset) {
-    auto const& info = writable_dataset.get_info();
-    bool const is_batch = info.is_batch();
-    Idx const batch_size = info.batch_size();
-    auto const& dataset_name = info.name();
-    DatasetMutable dataset_mutable{dataset_name, is_batch, batch_size};
-    OwningMemory storage{};
-
-    for (Idx component_idx{}; component_idx < info.n_components(); ++component_idx) {
-        auto const& component_name = info.component_name(component_idx);
-        auto const& component_meta = MetaData::get_component_by_name(dataset_name, component_name);
-        Idx const component_size = info.component_total_elements(component_idx);
-        Idx const elements_per_scenario = info.component_elements_per_scenario(component_idx);
-
-        auto& current_indptr = storage.indptrs.emplace_back(elements_per_scenario < 0 ? batch_size + 1 : 0);
-        if (!current_indptr.empty()) {
-            current_indptr.at(0) = 0;
-            current_indptr.at(batch_size) = component_size;
-        }
-        Idx* const indptr = current_indptr.empty() ? nullptr : current_indptr.data();
-        auto& current_buffer = storage.buffers.emplace_back(component_meta, component_size);
-        writable_dataset.set_buffer(component_name, indptr, current_buffer);
-        dataset_mutable.add_buffer(component_name, elements_per_scenario, component_size, indptr, current_buffer);
-    }
-    return OwningDataset{// NOLINT(modernize-use-designated-initializers)
-                         std::move(dataset_mutable), std::move(storage)};
-}
-} // namespace power_grid_model_cpp
-
-#endif // POWER_GRID_MODEL_CPP_SERIALIZATION_HPP
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+#ifndef POWER_GRID_MODEL_CPP_SERIALIZATION_HPP
+#define POWER_GRID_MODEL_CPP_SERIALIZATION_HPP
+
+#include "basics.hpp"
+#include "dataset.hpp"
+#include "handle.hpp"
+#include "meta_data.hpp"
+
+#include "power_grid_model_c/serialization.h"
+
+#include <cstring>
+
+namespace power_grid_model_cpp {
+class Deserializer {
+  public:
+    Deserializer(std::vector<std::byte> const& data, Idx serialization_format)
+        : deserializer_{handle_.call_with(PGM_create_deserializer_from_binary_buffer,
+                                          reinterpret_cast<const char*>(data.data()), static_cast<Idx>(data.size()),
+                                          serialization_format)},
+          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
+    Deserializer(std::vector<char> const& data, Idx serialization_format)
+        : deserializer_{handle_.call_with(PGM_create_deserializer_from_binary_buffer, data.data(),
+                                          static_cast<Idx>(data.size()), serialization_format)},
+          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
+    Deserializer(std::string const& data_string, Idx serialization_format)
+        : deserializer_{handle_.call_with(PGM_create_deserializer_from_null_terminated_string, data_string.c_str(),
+                                          serialization_format)},
+          dataset_{handle_.call_with(PGM_deserializer_get_dataset, get())} {}
+
+    RawDeserializer* get() { return deserializer_.get(); }
+    RawDeserializer const* get() const { return deserializer_.get(); }
+
+    DatasetWritable& get_dataset() { return dataset_; }
+
+    void parse_to_buffer() { handle_.call_with(PGM_deserializer_parse_to_buffer, get()); }
+
+  private:
+    Handle handle_{};
+    detail::UniquePtr<RawDeserializer, &PGM_destroy_deserializer> deserializer_;
+    DatasetWritable dataset_;
+};
+
+class Serializer {
+  public:
+    Serializer(DatasetConst const& dataset, Idx serialization_format)
+        : serializer_{handle_.call_with(PGM_create_serializer, dataset.get(), serialization_format)} {}
+
+    RawSerializer* get() { return serializer_.get(); }
+    RawSerializer const* get() const { return serializer_.get(); }
+
+    std::string_view get_to_binary_buffer(Idx use_compact_list) {
+        char const* temp_data{};
+        Idx buffer_size{};
+        handle_.call_with(PGM_serializer_get_to_binary_buffer, get(), use_compact_list, &temp_data, &buffer_size);
+        if (temp_data == nullptr) {
+            return std::string_view{};
+        } // empty data
+        return std::string_view{temp_data, static_cast<size_t>(buffer_size)};
+    }
+
+    void get_to_binary_buffer(Idx use_compact_list, std::vector<std::byte>& data) {
+        auto temp_data = get_to_binary_buffer(use_compact_list);
+        if (!temp_data.empty()) {
+            data.resize(temp_data.size());
+            std::memcpy(data.data(), temp_data.data(), temp_data.size());
+        } else {
+            data.resize(0); // empty data
+        }
+    }
+
+    void get_to_binary_buffer(Idx use_compact_list, std::vector<char>& data) {
+        auto temp_data = get_to_binary_buffer(use_compact_list);
+        if (!temp_data.empty()) {
+            data.assign(temp_data.begin(), temp_data.end());
+        } else {
+            data.resize(0); // empty data
+        }
+    }
+
+    std::string get_to_zero_terminated_string(Idx use_compact_list, Idx indent) {
+        return std::string{
+            handle_.call_with(PGM_serializer_get_to_zero_terminated_string, get(), use_compact_list, indent)};
+    }
+
+  private:
+    power_grid_model_cpp::Handle handle_{};
+    detail::UniquePtr<RawSerializer, &PGM_destroy_serializer> serializer_;
+};
+
+inline OwningDataset create_owning_dataset(DatasetWritable& writable_dataset) {
+    auto const& info = writable_dataset.get_info();
+    bool const is_batch = info.is_batch();
+    Idx const batch_size = info.batch_size();
+    auto const& dataset_name = info.name();
+    DatasetMutable dataset_mutable{dataset_name, is_batch, batch_size};
+    OwningMemory storage{};
+
+    for (Idx component_idx{}; component_idx < info.n_components(); ++component_idx) {
+        auto const& component_name = info.component_name(component_idx);
+        auto const& component_meta = MetaData::get_component_by_name(dataset_name, component_name);
+        Idx const component_size = info.component_total_elements(component_idx);
+        Idx const elements_per_scenario = info.component_elements_per_scenario(component_idx);
+
+        auto& current_indptr = storage.indptrs.emplace_back(elements_per_scenario < 0 ? batch_size + 1 : 0);
+        if (!current_indptr.empty()) {
+            current_indptr.at(0) = 0;
+            current_indptr.at(batch_size) = component_size;
+        }
+        Idx* const indptr = current_indptr.empty() ? nullptr : current_indptr.data();
+        auto& current_buffer = storage.buffers.emplace_back(component_meta, component_size);
+        writable_dataset.set_buffer(component_name, indptr, current_buffer);
+        dataset_mutable.add_buffer(component_name, elements_per_scenario, component_size, indptr, current_buffer);
+    }
+    return OwningDataset{// NOLINT(modernize-use-designated-initializers)
+                         std::move(dataset_mutable), std::move(storage)};
+}
+} // namespace power_grid_model_cpp
+
+#endif // POWER_GRID_MODEL_CPP_SERIALIZATION_HPP