SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
sddspp_write_demo.cc
Go to the documentation of this file.
1/**
2 * @file sddspp_write_demo.cc
3 * @brief Demonstrates writing every SDDS scalar type with SDDS++.
4 *
5 * This is the C++ counterpart of SDDSlib/demo/sdds_write_demo.c. It writes
6 * parameters, arrays, and columns to two pages of an ASCII SDDS file.
7 *
8 * @copyright
9 * - (c) 2026 The University of Chicago
10 *
11 * @license
12 * This file is distributed under the terms of the Software License Agreement
13 * found in the file LICENSE included with this distribution.
14 */
15
16#include "SDDS.hpp"
17
18#include <cstdint>
19#include <exception>
20#include <filesystem>
21#include <iostream>
22#include <optional>
23#include <string>
24#include <utility>
25#include <vector>
26
27namespace {
28
29/** @brief Creates a parameter definition for a named SDDS type. */
30sdds::ParameterDefinition parameter(std::string name, sdds::Type type) {
31 sdds::ParameterDefinition definition;
32 definition.name = std::move(name);
33 definition.type = type;
34 return definition;
35}
36
37/** @brief Creates an array definition for a named SDDS type. */
38sdds::ArrayDefinition array(std::string name, sdds::Type type,
39 std::int32_t dimensions) {
40 sdds::ArrayDefinition definition;
41 definition.name = std::move(name);
42 definition.type = type;
43 definition.dimensions = dimensions;
44 return definition;
45}
46
47/** @brief Creates a column definition for a named SDDS type. */
48sdds::ColumnDefinition column(std::string name, sdds::Type type) {
49 sdds::ColumnDefinition definition;
50 definition.name = std::move(name);
51 definition.type = type;
52 return definition;
53}
54
55/** @brief Builds the layout shared by both output pages. */
56sdds::Layout makeLayout() {
57 sdds::DataOptions data;
58 data.mode = sdds::DataMode::Ascii;
59 data.linesPerRow = 1;
60
61 sdds::LayoutBuilder builder;
62 builder.setDescription("Example SDDS Output", "SDDS++ Example")
63 .setDataOptions(data);
64
65 const std::vector<std::pair<const char *, sdds::Type>> fields = {
66 {"short", sdds::Type::Int16},
67 {"ushort", sdds::Type::UInt16},
68 {"long", sdds::Type::Int32},
69 {"ulong", sdds::Type::UInt32},
70 {"long64", sdds::Type::Int64},
71 {"ulong64", sdds::Type::UInt64},
72 {"float", sdds::Type::Float},
73 {"double", sdds::Type::Double},
74 {"longdouble", sdds::Type::LongDouble},
75 {"string", sdds::Type::String},
76 {"char", sdds::Type::Character},
77 };
78
79 for (const auto &[name, type] : fields) {
80 builder.addParameter(parameter(std::string(name) + "Param", type));
81 const bool oneDimensional = type == sdds::Type::Int16 ||
82 type == sdds::Type::UInt16 ||
83 type == sdds::Type::Int32 ||
84 type == sdds::Type::UInt32;
85 builder.addArray(array(std::string(name) + "Array", type,
86 oneDimensional ? 1 : 2));
87 builder.addColumn(column(std::string(name) + "Col", type));
88 }
89 return builder.build();
90}
91
92/** @brief Writes the first page from the original C demonstration. */
93void writeFirstPage(sdds::Writer &writer) {
94 writer.beginPage(5);
95 writer.setParameter("shortParam", std::int16_t{10});
96 writer.setParameter("ushortParam", std::uint16_t{11});
97 writer.setParameter("longParam", std::int32_t{1000});
98 writer.setParameter("ulongParam", std::uint32_t{1001});
99 writer.setParameter("long64Param", std::int64_t{1002});
100 writer.setParameter("ulong64Param", std::uint64_t{1003});
101 writer.setParameter("floatParam", 3.14F);
102 writer.setParameter("doubleParam", 2.71828);
103 writer.setParameter("longdoubleParam", 1.1L);
104 writer.setParameter("stringParam", std::string("FirstPage"));
105 writer.setParameter("charParam", 'A');
106
107 writer.setArray("shortArray", {{3}, std::vector<std::int16_t>{1, 2, 3}});
108 writer.setArray("ushortArray", {{3}, std::vector<std::uint16_t>{4, 5, 6}});
109 writer.setArray("longArray", {{3}, std::vector<std::int32_t>{1000, 2000, 3000}});
110 writer.setArray("ulongArray", {{3}, std::vector<std::uint32_t>{1001, 2001, 3001}});
111 writer.setArray("long64Array", {{4, 2}, std::vector<std::int64_t>{
112 1002, 2002, 3002, 4002, 5002, 6002, 7002, 8002}});
113 writer.setArray("ulong64Array", {{4, 2}, std::vector<std::uint64_t>{
114 1003, 2003, 3003, 4003, 5003, 6003, 7003, 8003}});
115 writer.setArray("floatArray", {{4, 2}, std::vector<float>{
116 1.1F, 1.2F, 1.3F, 1.4F, 1.5F, 1.6F, 1.7F, 1.8F}});
117 writer.setArray("doubleArray", {{4, 2}, std::vector<double>{
118 1.2, 2.2, 3.2, 4.2, 5.2, 6.2, 7.2, 8.2}});
119 writer.setArray("longdoubleArray", {{4, 2}, std::vector<long double>{
120 1.3L, 2.3L, 3.3L, 4.3L, 5.3L, 6.3L, 7.3L, 8.3L}});
121 writer.setArray("stringArray", {{4, 2}, std::vector<std::string>{
122 "one", "two", "three", "four", "five", "six", "seven", "eight"}});
123 writer.setArray("charArray", {{4, 2}, std::vector<char>{
124 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'}});
125
126 writer.setColumn("shortCol", std::vector<std::int16_t>{1, 2, 3, 4, 5});
127 writer.setColumn("ushortCol", std::vector<std::uint16_t>{1, 2, 3, 4, 5});
128 writer.setColumn("longCol", std::vector<std::int32_t>{100, 200, 300, 400, 500});
129 writer.setColumn("ulongCol", std::vector<std::uint32_t>{100, 200, 300, 400, 500});
130 writer.setColumn("long64Col", std::vector<std::int64_t>{100, 200, 300, 400, 500});
131 writer.setColumn("ulong64Col", std::vector<std::uint64_t>{100, 200, 300, 400, 500});
132 writer.setColumn("floatCol", std::vector<float>{1.1F, 2.2F, 3.3F, 4.4F, 5.5F});
133 writer.setColumn("doubleCol", std::vector<double>{10.01, 20.02, 30.03, 40.04, 50.05});
134 writer.setColumn("longdoubleCol", std::vector<long double>{
135 10.01L, 20.02L, 30.03L, 40.04L, 50.05L});
136 writer.setColumn("stringCol", std::vector<std::string>{
137 "one", "two", "three", "four", "five"});
138 writer.setColumn("charCol", std::vector<char>{'a', 'b', 'c', 'd', 'e'});
139 writer.commitPage();
140}
141
142/** @brief Writes the second page from the original C demonstration. */
143void writeSecondPage(sdds::Writer &writer) {
144 writer.beginPage(3);
145 writer.setParameter("shortParam", std::int16_t{20});
146 writer.setParameter("ushortParam", std::uint16_t{21});
147 writer.setParameter("longParam", std::int32_t{2000});
148 writer.setParameter("ulongParam", std::uint32_t{2001});
149 writer.setParameter("long64Param", std::int64_t{2002});
150 writer.setParameter("ulong64Param", std::uint64_t{2003});
151 writer.setParameter("floatParam", 6.28F);
152 writer.setParameter("doubleParam", 1.41421);
153 writer.setParameter("longdoubleParam", 2.2L);
154 writer.setParameter("stringParam", std::string("SecondPage"));
155 writer.setParameter("charParam", 'B');
156
157 writer.setArray("shortArray", {{2}, std::vector<std::int16_t>{7, 8}});
158 writer.setArray("ushortArray", {{2}, std::vector<std::uint16_t>{9, 10}});
159 writer.setArray("longArray", {{2}, std::vector<std::int32_t>{4000, 5000}});
160 writer.setArray("ulongArray", {{2}, std::vector<std::uint32_t>{4001, 5001}});
161 writer.setArray("long64Array", {{2, 2}, std::vector<std::int64_t>{4002, 5002, 6002, 7002}});
162 writer.setArray("ulong64Array", {{2, 2}, std::vector<std::uint64_t>{4003, 5003, 6003, 7003}});
163 writer.setArray("floatArray", {{2, 2}, std::vector<float>{11.11F, 22.22F, 33.33F, 44.44F}});
164 writer.setArray("doubleArray", {{2, 2}, std::vector<double>{33.33, 44.44, 55.55, 66.66}});
165 writer.setArray("longdoubleArray", {{2, 2}, std::vector<long double>{
166 55.55L, 66.66L, 77.77L, 88.88L}});
167 writer.setArray("stringArray", {{2, 2}, std::vector<std::string>{
168 "blue", "red", "yellow", "gold"}});
169 writer.setArray("charArray", {{2, 2}, std::vector<char>{'W', 'X', 'Y', 'Z'}});
170
171 writer.setColumn("shortCol", std::vector<std::int16_t>{6, 7, 8});
172 writer.setColumn("ushortCol", std::vector<std::uint16_t>{6, 7, 8});
173 writer.setColumn("longCol", std::vector<std::int32_t>{600, 700, 800});
174 writer.setColumn("ulongCol", std::vector<std::uint32_t>{600, 700, 800});
175 writer.setColumn("long64Col", std::vector<std::int64_t>{600, 700, 800});
176 writer.setColumn("ulong64Col", std::vector<std::uint64_t>{600, 700, 800});
177 writer.setColumn("floatCol", std::vector<float>{6.6F, 7.7F, 8.8F});
178 writer.setColumn("doubleCol", std::vector<double>{60.06, 70.07, 80.08});
179 writer.setColumn("longdoubleCol", std::vector<long double>{60.06L, 70.07L, 80.08L});
180 writer.setColumn("stringCol", std::vector<std::string>{"six", "seven", "eight"});
181 writer.setColumn("charCol", std::vector<char>{'f', 'g', 'h'});
182 writer.commitPage();
183}
184
185} // namespace
186
187/**
188 * @brief Writes an SDDS++ example file.
189 * @param argc Argument count; an optional output path may be supplied.
190 * @param argv Argument vector.
191 * @return Zero on success, nonzero on failure.
192 */
193int main(int argc, char **argv) {
194 if (argc > 2) {
195 std::cerr << "usage: " << argv[0] << " [output.sdds]\n";
196 return 1;
197 }
198
199 const std::filesystem::path output = argc == 2 ? argv[1] : "example.sdds";
200 try {
201 auto writer = sdds::Writer::create(output, makeLayout());
202 writeFirstPage(writer);
203 writeSecondPage(writer);
204 writer.close();
205 std::cout << "Wrote " << output << "\n";
206 } catch (const std::exception &error) {
207 std::cerr << "Unable to write " << output << ": " << error.what() << '\n';
208 return 1;
209 }
210 return 0;
211}
main
int main(int argc, char **argv)
Writes an SDDS++ example file.
Definition sddspp_write_demo.cc:193
Generated by doxygen 1.12.0