SDDSTransform.cc File Reference

Detailed Description

Typed layout and page transformations for the C++17 SDDS interface.

Implements checked scalar and vector conversions, layout editing, row masks and views, page filtering and projection, unit conversion, and streaming transformed copies.

Copyright

• (c) 2026 The University of Chicago

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Definition in file SDDSTransform.cc.

#include "SDDS.hpp"
#include <algorithm>
#include <cmath>
#include <limits>
#include <type_traits>

Go to the source code of this file.

Functions
Scalar	sdds::convertScalar (const Scalar &value, Type target, RoundingMode rounding)
Values	sdds::convertValues (const Values &values, Type target, RoundingMode rounding)
Page	sdds::convertUnits (const Page &page, FieldKind kind, std::string_view name, std::optional< std::string > units, long double factor)
void	sdds::copyDataset (Reader &reader, const std::filesystem::path &output, CopyOptions options)

Function Documentation

convertScalar()

Scalar sdds::convertScalar	(	const Scalar &	value,
		Type	target,
		RoundingMode	rounding )

Definition at line 233 of file SDDSTransform.cc.

                                                                              {
  if (target == Type::String) {
    if (const auto *text = std::get_if<std::string>(&value))
      return *text;
    typeError("numeric values cannot be implicitly converted to strings");
  }
  switch (target) {
  case Type::LongDouble: return convertTo<long double>(value, rounding);
  case Type::Double: return convertTo<double>(value, rounding);
  case Type::Float: return convertTo<float>(value, rounding);
  case Type::Int64: return convertTo<std::int64_t>(value, rounding);
  case Type::UInt64: return convertTo<std::uint64_t>(value, rounding);
  case Type::Int32: return convertTo<std::int32_t>(value, rounding);
  case Type::UInt32: return convertTo<std::uint32_t>(value, rounding);
  case Type::Int16: return convertTo<std::int16_t>(value, rounding);
  case Type::UInt16: return convertTo<std::uint16_t>(value, rounding);
  case Type::Character: return convertTo<char>(value, rounding);
  case Type::String: break;
  }
  typeError("unknown conversion target");
}

convertUnits()

Page sdds::convertUnits	(	const Page &	page,
		FieldKind	kind,
		std::string_view	name,
		std::optional< std::string >	units,
		long double	factor )

Definition at line 430 of file SDDSTransform.cc.

                                                                    {
  Layout changed = page.layout();
  if (!std::isfinite(factor)) typeError("unit conversion factor must be finite");
  switch (kind) {
  case FieldKind::Parameter: changed.parameters.at(changed.parameterIndex(name)).units = units; break;
  case FieldKind::Array: changed.arrays.at(changed.arrayIndex(name)).units = units; break;
  case FieldKind::Column: changed.columns.at(changed.columnIndex(name)).units = units; break;
  }
  auto layout = std::make_shared<const Layout>(LayoutBuilder(std::move(changed)).build());
  Page result(layout, LoadMode::None);
  result.maxTransformationElements_ = page.maxTransformationElements_;
  result.number_ = page.number_;
  result.recovered_ = page.recovered_;
  result.rowCount_ = page.rowCount_;
  for (std::size_t index = 0; index < page.parameters_.size(); ++index) {
    if (!page.parameterLoaded(index)) continue;
    Scalar value = page.parameters_[index];
    if (kind == FieldKind::Parameter && page.layout().parameters[index].name == name)
      value = scaledScalar(value, page.layout().parameters[index].type, factor);
    result.setParameter(index, std::move(value));
  }
  for (std::size_t index = 0; index < page.arrays_.size(); ++index) {
    if (!page.arrayLoaded(index)) continue;
    ArrayData value = page.arrays_[index];
    if (kind == FieldKind::Array && page.layout().arrays[index].name == name)
      value.values = scaledValues(value.values, page.layout().arrays[index].type, factor);
    result.setArray(index, std::move(value));
  }
  for (std::size_t index = 0; index < page.columns_.size(); ++index) {
    if (!page.columnLoaded(index)) continue;
    Values value = page.columns_[index];
    if (kind == FieldKind::Column && page.layout().columns[index].name == name)
      value = scaledValues(value, page.layout().columns[index].type, factor);
    result.setColumn(index, std::move(value));
  }
  result.rowCount_ = page.rowCount_;
  return result;
}

convertValues()

Values sdds::convertValues	(	const Values &	values,
		Type	target,
		RoundingMode	rounding )

Definition at line 255 of file SDDSTransform.cc.

                                                                               {
  if (typeOf(values) == target)
    return values;
  Values result = emptyValues(target);
  const std::size_t count = std::visit([](const auto &items) { return items.size(); }, values);
  for (std::size_t index = 0; index < count; ++index)
    appendScalar(result, convertScalar(scalarAt(values, index), target, rounding));
  return result;
}

copyDataset()

void sdds::copyDataset	(	Reader &	reader,
		const std::filesystem::path &	output,
		CopyOptions	options )

Definition at line 470 of file SDDSTransform.cc.

                                                                                       {
  Layout outputLayout = options.transformLayout ? options.transformLayout(reader.layout())
                                                : reader.layout();
  auto shared = std::make_shared<const Layout>(outputLayout);
  Writer writer = Writer::create(output, outputLayout, options.writer);
  while (auto page = reader.next(options.read)) {
    if (options.transformPage) {
      auto transformed = options.transformPage(std::move(*page), shared);
      if (transformed) writer.write(std::move(*transformed));
    } else {
      writer.write(std::move(*page));
    }
  }
  writer.close();
}