SDDS ToolKit Programs and Libraries for C and Python
Loading...
Searching...
No Matches
SDDSParameter.cc
Go to the documentation of this file.
1/**
2 * @file SDDSParameter.cc
3 * @brief Archived implementation of the original SDDS3 parameter class.
4 *
5 * @details Provides legacy parameter definition, conversion, and page-storage
6 * routines for builds that explicitly enable the unmodernized SDDS3 API.
7 *
8 * @note This source is retained for migration reference and is not compiled
9 * into libSDDSpp.
10 *
11 * @copyright
12 * - (c) The University of Chicago
13 *
14 * @license
15 * This file is distributed under the terms of the Software License Agreement
16 * found in the file LICENSE included with this distribution.
17 */
18
19/* GUIDELINES
20 Do not exit or print to stdout or stderr from any of the functions in this file
21*/
22
23/* TODO
24 Ensure that strtod returns HUGE_VAL on all operating systems.
25 Modify setType so that it can change the type of an existing parameter.
26 Add ability to add pages if only fixedvalue parameters exist.
27*/
28
29#include <stdio.h>
30#include <string.h>
31#include <stdlib.h>
32#include <stdarg.h>
33#include <ctype.h>
34#include <limits.h>
35#include <math.h>
36#include <float.h>
37#include "SDDS3.h"
38
39
40/***********************************************************************************************
41 * SDDSParameter *
42 * *
43 * C++ Arguments: none *
44 * *
45 * Results: pointer to SDDSParameter object *
46 ***********************************************************************************************/
47SDDSParameter::SDDSParameter() {
48 pageCount = 0;
49 parameterType = 0;
50 fixed = false;
51 parameterName = NULL;
52 parameterSymbol = NULL;
53 parameterUnits = NULL;
54 parameterDescription = NULL;
55 parameterFormatString = NULL;
56 parameterFixedValue = NULL;
57 int32Value = NULL;
58 int16Value = NULL;
59 uint32Value = NULL;
60 uint16Value = NULL;
61 real64Value = NULL;
62 real32Value = NULL;
63 stringValue = NULL;
64 charValue = NULL;
65 sddsfile = NULL;
66}
67
68/***********************************************************************************************
69 * ~SDDSParameter *
70 * *
71 * C++ Arguments: none *
72 * *
73 * Results: none *
74 ***********************************************************************************************/
75SDDSParameter::~SDDSParameter() {
76 uint32_t i;
77 if (parameterName != NULL)
78 SDDS_free(parameterName);
79 if (parameterSymbol != NULL)
80 SDDS_free(parameterSymbol);
81 if (parameterUnits != NULL)
82 SDDS_free(parameterUnits);
83 if (parameterDescription != NULL)
84 SDDS_free(parameterDescription);
85 if (parameterFormatString != NULL)
86 SDDS_free(parameterFormatString);
87 if (parameterFixedValue != NULL)
88 SDDS_free(parameterFixedValue);
89 if (int16Value != NULL)
90 SDDS_free(int16Value);
91 if (uint16Value != NULL)
92 SDDS_free(uint16Value);
93 if (int32Value != NULL)
94 SDDS_free(int32Value);
95 if (uint32Value != NULL)
96 SDDS_free(uint32Value);
97 if (real32Value != NULL)
98 SDDS_free(real32Value);
99 if (real64Value != NULL)
100 SDDS_free(real64Value);
101 if (stringValue != NULL) {
102 for (i=0; i<pageCount; i++) {
103 if (stringValue[i] != NULL) {
104 SDDS_free(stringValue[i]);
105 }
106 }
107 SDDS_free(stringValue);
108 }
109 if (charValue != NULL)
110 SDDS_free(charValue);
111}
112
113/***********************************************************************************************
114 * freePage *
115 * *
116 * C++ Arguments: none *
117 * *
118 * Results: none *
119 ***********************************************************************************************/
120void SDDSParameter::freePage() {
121 uint32_t i;
122 switch (parameterType) {
123 case SDDS_INT16:
124 if (int16Value != NULL)
125 SDDS_free(int16Value);
126 int16Value = NULL;
127 break;
128 case SDDS_UINT16:
129 if (uint16Value != NULL)
130 SDDS_free(uint16Value);
131 uint16Value = NULL;
132 break;
133 case SDDS_INT32:
134 if (int32Value != NULL)
135 SDDS_free(int32Value);
136 int32Value = NULL;
137 break;
138 case SDDS_UINT32:
139 if (uint32Value != NULL)
140 SDDS_free(uint32Value);
141 uint32Value = NULL;
142 break;
143 case SDDS_REAL32:
144 if (real32Value != NULL)
145 SDDS_free(real32Value);
146 real32Value = NULL;
147 break;
148 case SDDS_REAL64:
149 if (real64Value != NULL)
150 SDDS_free(real64Value);
151 real64Value = NULL;
152 break;
153 case SDDS_STRING:
154 if (stringValue != NULL) {
155 for (i=0; i<pageCount; i++) {
156 if (stringValue[i] != NULL) {
157 SDDS_free(stringValue[i]);
158 }
159 }
160 SDDS_free(stringValue);
161 stringValue = NULL;
162 }
163 break;
164 case SDDS_CHARACTER:
165 if (charValue != NULL)
166 SDDS_free(charValue);
167 charValue = NULL;
168 break;
169 default:
170 break;
171 }
172 pageCount = 0;
173}
174
175/***********************************************************************************************
176 * setupParameter *
177 * *
178 * C++ Arguments: char *name, char *symbol, char *units, char *description, *
179 * char *format_string, int32_t type, char *fixed_value *
180 * *
181 * Results: none *
182 ***********************************************************************************************/
183void SDDSParameter::setupParameter(char *name, char *symbol, char *units, char *description, char *format_string, int32_t type, char *fixed_value) {
184 if (parameterName != NULL)
185 SDDS_free(parameterName);
186 if (parameterSymbol != NULL)
187 SDDS_free(parameterSymbol);
188 if (parameterUnits != NULL)
189 SDDS_free(parameterUnits);
190 if (parameterDescription != NULL)
191 SDDS_free(parameterDescription);
192 if (parameterFormatString != NULL)
193 SDDS_free(parameterFormatString);
194 if (parameterFixedValue != NULL)
195 SDDS_free(parameterFixedValue);
196
197 if (name == NULL)
198 parameterName = NULL;
199 else {
200 parameterName = (char*)SDDS_malloc(sizeof(char) * strlen(name) + 1);
201 strcpy(parameterName, name);
202 }
203 if (symbol == NULL)
204 parameterSymbol = NULL;
205 else {
206 parameterSymbol = (char*)SDDS_malloc(sizeof(char) * strlen(symbol) + 1);
207 strcpy(parameterSymbol, symbol);
208 }
209 if (units == NULL)
210 parameterUnits = NULL;
211 else {
212 parameterUnits = (char*)SDDS_malloc(sizeof(char) * strlen(units) + 1);
213 strcpy(parameterUnits, units);
214 }
215 if (description == NULL)
216 parameterDescription = NULL;
217 else {
218 parameterDescription = (char*)SDDS_malloc(sizeof(char) * strlen(description) + 1);
219 strcpy(parameterDescription, description);
220 }
221 if (format_string == NULL)
222 parameterFormatString = NULL;
223 else {
224 parameterFormatString = (char*)SDDS_malloc(sizeof(char) * strlen(format_string) + 1);
225 strcpy(parameterFormatString, format_string);
226 }
227 if (fixed_value == NULL) {
228 parameterFixedValue = NULL;
229 fixed = false;
230 } else {
231 parameterFixedValue = (char*)SDDS_malloc(sizeof(char) * strlen(fixed_value) + 1);
232 strcpy(parameterFixedValue, fixed_value);
233 fixed = true;
234 }
235 parameterType = type;
236}
237
238/***********************************************************************************************
239 * informAboutParent *
240 * *
241 * C++ Arguments: SDDSFile *parent *
242 * *
243 * Results: none *
244 ***********************************************************************************************/
245void SDDSParameter::informAboutParent(void *parent) {
246 sddsfile = parent;
247}
248
249/***********************************************************************************************
250 * getName *
251 * *
252 * C++ Arguments: none *
253 * *
254 * Results: pointer to name (do not free the result) *
255 ***********************************************************************************************/
256char* SDDSParameter::getName() {
257 return(parameterName);
258}
259
260/***********************************************************************************************
261 * setName *
262 * *
263 * C++ Arguments: char *name *
264 * *
265 * Results: none *
266 ***********************************************************************************************/
267void SDDSParameter::setName(char *name) {
268 if (parameterName != NULL)
269 SDDS_free(parameterName);
270 if (name == NULL)
271 parameterName = NULL;
272 else {
273 parameterName = (char*)SDDS_malloc(sizeof(char) * strlen(name) + 1);
274 strcpy(parameterName, name);
275 }
276}
277
278/***********************************************************************************************
279 * getSymbol *
280 * *
281 * C++ Arguments: none *
282 * *
283 * Results: pointer to symbol (do not free the result) *
284 ***********************************************************************************************/
285char* SDDSParameter::getSymbol() {
286 return(parameterSymbol);
287}
288
289/***********************************************************************************************
290 * setSymbol *
291 * *
292 * C++ Arguments: char *symbol *
293 * *
294 * Results: none *
295 ***********************************************************************************************/
296void SDDSParameter::setSymbol(char *symbol) {
297 if (parameterSymbol != NULL)
298 SDDS_free(parameterSymbol);
299 if (symbol == NULL)
300 parameterSymbol = NULL;
301 else {
302 parameterSymbol = (char*)SDDS_malloc(sizeof(char) * strlen(symbol) + 1);
303 strcpy(parameterSymbol, symbol);
304 }
305}
306
307/***********************************************************************************************
308 * getUnits *
309 * *
310 * C++ Arguments: none *
311 * *
312 * Results: pointer to the units (do not free the result) *
313 ***********************************************************************************************/
314char* SDDSParameter::getUnits() {
315 return(parameterUnits);
316}
317
318/***********************************************************************************************
319 * setUnits *
320 * *
321 * C++ Arguments: char *units *
322 * *
323 * Results: none *
324 ***********************************************************************************************/
325void SDDSParameter::setUnits(char *units) {
326 if (parameterUnits != NULL)
327 SDDS_free(parameterUnits);
328 if (units == NULL)
329 parameterUnits = NULL;
330 else {
331 parameterUnits = (char*)SDDS_malloc(sizeof(char) * strlen(units) + 1);
332 strcpy(parameterUnits, units);
333 }
334}
335
336/***********************************************************************************************
337 * getDescription *
338 * *
339 * C++ Arguments: none *
340 * *
341 * Results: pointer to the description (do not free the result) *
342 ***********************************************************************************************/
343char* SDDSParameter::getDescription() {
344 return(parameterDescription);
345}
346
347/***********************************************************************************************
348 * setDescription *
349 * *
350 * C++ Arguments: char *description *
351 * *
352 * Results: none *
353 ***********************************************************************************************/
354void SDDSParameter::setDescription(char *description) {
355 if (parameterDescription != NULL)
356 SDDS_free(parameterDescription);
357 if (description == NULL)
358 parameterDescription = NULL;
359 else {
360 parameterDescription = (char*)SDDS_malloc(sizeof(char) * strlen(description) + 1);
361 strcpy(parameterDescription, description);
362 }
363}
364
365/***********************************************************************************************
366 * getFormatString *
367 * *
368 * C++ Arguments: none *
369 * *
370 * Results: pointer to the format string (do not free the result) *
371 ***********************************************************************************************/
372char* SDDSParameter::getFormatString() {
373 return(parameterFormatString);
374}
375
376/***********************************************************************************************
377 * setFormatString *
378 * *
379 * C++ Arguments: char *format_string *
380 * *
381 * Results: none *
382 ***********************************************************************************************/
383void SDDSParameter::setFormatString(char *format_string) {
384 if (parameterFormatString != NULL)
385 SDDS_free(parameterFormatString);
386 if (format_string == NULL)
387 parameterFormatString = NULL;
388 else {
389 parameterFormatString = (char*)SDDS_malloc(sizeof(char) * strlen(format_string) + 1);
390 strcpy(parameterFormatString, format_string);
391 }
392}
393
394/***********************************************************************************************
395 * getFixedValue *
396 * *
397 * C++ Arguments: none *
398 * *
399 * Results: pointer to the fixed value (do not free the result) *
400 ***********************************************************************************************/
401char* SDDSParameter::getFixedValue() {
402 return(parameterFixedValue);
403}
404
405/***********************************************************************************************
406 * setFixedValue *
407 * *
408 * Note: you can turn off fixed value by sending a NULL value *
409 * *
410 * C++ Arguments: char *fixed_value *
411 * *
412 * Results: none *
413 ***********************************************************************************************/
414void SDDSParameter::setFixedValue(char *fixed_value) {
415 if (parameterFixedValue != NULL)
416 SDDS_free(parameterFixedValue);
417 if (fixed_value == NULL) {
418 parameterFixedValue = NULL;
419 fixed = false;
420 } else {
421 parameterFixedValue = (char*)SDDS_malloc(sizeof(char) * strlen(fixed_value) + 1);
422 strcpy(parameterFixedValue, fixed_value);
423 fixed = true;
424 }
425}
426
427/***********************************************************************************************
428 * getType *
429 * *
430 * C++ Arguments: none *
431 * *
432 * Results: the parameter type in integer form *
433 ***********************************************************************************************/
434int32_t SDDSParameter::getType() {
435 return(parameterType);
436}
437
438/***********************************************************************************************
439 * setType *
440 * *
441 * C++ Arguments:int32_t type *
442 * *
443 * Results: none *
444 ***********************************************************************************************/
445void SDDSParameter::setType(int32_t type) {
446 parameterType = type;
447}
448
449/***********************************************************************************************
450 * getPageCount *
451 * *
452 * C++ Arguments: none *
453 * *
454 * Results: the page count *
455 ***********************************************************************************************/
456uint32_t SDDSParameter::getPageCount() {
457 return(pageCount);
458}
459
460/***********************************************************************************************
461 * setValue *
462 * *
463 * C++ Arguments: int32_t value, uint32_t page *
464 * uint32_t value, uint32_t page *
465 * double value, uint32_t page *
466 * char *value, uint32_t page *
467 * *
468 * Results: 0 for success *
469 * 1 for invalid page number *
470 * 2 for the case where the value cannot be converted to the proper parameter type *
471 * 3 for invalid parameter type *
472 ***********************************************************************************************/
473int32_t SDDSParameter::setValue(int32_t value, uint32_t page) {
474 uint32_t n=0, i;
475 bool newPage=false;
476 char s[SDDS_MAXLINE];
477 if (page == 0)
478 return(1);
479 if (page > pageCount) {
480 newPage = true;
481 n = page - pageCount;
482 }
483 if (fixed)
484 setFixedValue(NULL);
485 /* if n > 1 then put 0 values in skipped pages */
486 switch (parameterType) {
487 case SDDS_INT16:
488 if (newPage) {
489 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
490 for (i=2; i<=n; i++)
491 int16Value[page - i] = (int16_t)0;
492 }
493 int16Value[page-1] = (int16_t)value;
494 break;
495 case SDDS_UINT16:
496 if (newPage) {
497 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
498 for (i=2; i<=n; i++)
499 uint16Value[page - i] = (uint16_t)0;
500 }
501 uint16Value[page-1] = (uint16_t)value;
502 break;
503 case SDDS_INT32:
504 if (newPage) {
505 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
506 for (i=2; i<=n; i++)
507 int32Value[page - i] = (int32_t)0;
508 }
509 int32Value[page-1] = (int32_t)value;
510 break;
511 case SDDS_UINT32:
512 if (newPage) {
513 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
514 for (i=2; i<=n; i++)
515 uint32Value[page - i] = (uint32_t)0;
516 }
517 uint32Value[page-1] = (uint32_t)value;
518 break;
519 case SDDS_REAL32:
520 if (newPage) {
521 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
522 for (i=2; i<=n; i++)
523 real32Value[page - i] = (float)0;
524 }
525 real32Value[page-1] = (float)value;
526 break;
527 case SDDS_REAL64:
528 if (newPage) {
529 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
530 for (i=2; i<=n; i++)
531 real64Value[page - i] = (double)0;
532 }
533 real64Value[page-1] = (double)value;
534 break;
535 case SDDS_STRING:
536 if (newPage) {
537 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
538 for (i=2; i<=n; i++)
539 stringValue[page - i] = NULL;
540 }
541 sprintf(s, "%" PRId32, value);
542 stringValue[page-1] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
543 strcpy(stringValue[page-1], s);
544 break;
545 case SDDS_CHARACTER:
546 if (newPage) {
547 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
548 for (i=2; i<=n; i++)
549 charValue[page - i] = 0;
550 }
551 charValue[page-1] = (char)value;
552 break;
553 default:
554 return(3);
555 }
556 if (newPage)
557 pageCount = page;
558 return(0);
559}
560
561int32_t SDDSParameter::setValue(uint32_t value, uint32_t page) {
562 uint32_t n=0, i;
563 bool newPage=false;
564 char s[SDDS_MAXLINE];
565 if (page == 0)
566 return(1);
567 if (page > pageCount) {
568 newPage = true;
569 n = page - pageCount;
570 }
571 if (fixed)
572 setFixedValue(NULL);
573 /* if n > 1 then put 0 values in skipped pages */
574 switch (parameterType) {
575 case SDDS_INT16:
576 if (n > 0) {
577 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
578 for (i=2; i<=n; i++)
579 int16Value[page - i] = (int16_t)0;
580 }
581 int16Value[page-1] = (int16_t)value;
582 break;
583 case SDDS_UINT16:
584 if (n > 0) {
585 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
586 for (i=2; i<=n; i++)
587 uint16Value[page - i] = (uint16_t)0;
588 }
589 uint16Value[page-1] = (uint16_t)value;
590 break;
591 case SDDS_INT32:
592 if (n > 0) {
593 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
594 for (i=2; i<=n; i++)
595 int32Value[page - i] = (int32_t)0;
596 }
597 int32Value[page-1] = (int32_t)value;
598 break;
599 case SDDS_UINT32:
600 if (n > 0) {
601 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
602 for (i=2; i<=n; i++)
603 uint32Value[page - i] = (uint32_t)0;
604 }
605 uint32Value[page-1] = (uint32_t)value;
606 break;
607 case SDDS_REAL32:
608 if (n > 0) {
609 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
610 for (i=2; i<=n; i++)
611 real32Value[page - i] = (float)0;
612 }
613 real32Value[page-1] = (float)value;
614 break;
615 case SDDS_REAL64:
616 if (n > 0) {
617 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
618 for (i=2; i<=n; i++)
619 real64Value[page - i] = (double)0;
620 }
621 real64Value[page-1] = (double)value;
622 break;
623 case SDDS_STRING:
624 if (n > 0) {
625 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
626 for (i=2; i<=n; i++)
627 stringValue[page - i] = NULL;
628 }
629 sprintf(s, "%" PRIu32, value);
630 stringValue[page-1] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
631 strcpy(stringValue[page-1], s);
632 break;
633 case SDDS_CHARACTER:
634 if (n > 0) {
635 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
636 for (i=2; i<=n; i++)
637 charValue[page - i] = 0;
638 }
639 charValue[page-1] = (char)value;
640 break;
641 default:
642 return(3);
643 }
644 if (n > 0)
645 pageCount = page;
646 return(0);
647}
648
649int32_t SDDSParameter::setValue(double value, uint32_t page) {
650 uint32_t n=0, i;
651 bool newPage=false;
652 char s[SDDS_MAXLINE];
653 if (page == 0)
654 return(1);
655 if (page > pageCount) {
656 newPage = true;
657 n = page - pageCount;
658 }
659 if (fixed)
660 setFixedValue(NULL);
661 /* if n > 1 then put 0 values in skipped pages */
662 switch (parameterType) {
663 case SDDS_INT16:
664 if (newPage) {
665 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
666 for (i=2; i<=n; i++)
667 int16Value[page - i] = (int16_t)0;
668 }
669 int16Value[page-1] = (int16_t)value;
670 break;
671 case SDDS_UINT16:
672 if (newPage) {
673 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
674 for (i=2; i<=n; i++)
675 uint16Value[page - i] = (uint16_t)0;
676 }
677 uint16Value[page-1] = (uint16_t)value;
678 break;
679 case SDDS_INT32:
680 if (newPage) {
681 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
682 for (i=2; i<=n; i++)
683 int32Value[page - i] = (int32_t)0;
684 }
685 int32Value[page-1] = (int32_t)value;
686 break;
687 case SDDS_UINT32:
688 if (newPage) {
689 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
690 for (i=2; i<=n; i++)
691 uint32Value[page - i] = (uint32_t)0;
692 }
693 uint32Value[page-1] = (uint32_t)value;
694 break;
695 case SDDS_REAL32:
696 if (newPage) {
697 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
698 for (i=2; i<=n; i++)
699 real32Value[page - i] = (float)0;
700 }
701 real32Value[page-1] = (float)value;
702 break;
703 case SDDS_REAL64:
704 if (newPage) {
705 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
706 for (i=2; i<=n; i++)
707 real64Value[page - i] = (double)0;
708 }
709 real64Value[page-1] = (double)value;
710 break;
711 case SDDS_STRING:
712 if (newPage) {
713 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
714 for (i=2; i<=n; i++)
715 stringValue[page - i] = NULL;
716 }
717 sprintf(s, "%lf", value);
718 stringValue[page-1] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
719 strcpy(stringValue[page-1], s);
720 break;
721 case SDDS_CHARACTER:
722 if (newPage) {
723 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
724 for (i=2; i<=n; i++)
725 charValue[page - i] = 0;
726 }
727 charValue[page-1] = (char)value;
728 break;
729 default:
730 return(3);
731 }
732 if (newPage)
733 pageCount = page;
734 return(0);
735}
736
737int32_t SDDSParameter::setValue(char *value, uint32_t page) {
738 int32_t returnVal=0;
739 uint32_t n=0, i;
740 bool newPage=false;
741 int64_t iValue=0;
742 double dValue=0;
743
744 if (page == 0)
745 return(1);
746 if (page > pageCount) {
747 newPage = true;
748 n = page - pageCount;
749 }
750 if (fixed)
751 setFixedValue(NULL);
752 if (SDDS_INTEGER_TYPE(parameterType)) {
753 iValue = strtoll(value, (char**)NULL, 10);
754 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
755 /*unable to convert given string to integer parameter*/
756 returnVal=2;
757 iValue=0;
758 }
759 } else if (SDDS_FLOATING_TYPE(parameterType)) {
760 dValue = strtod(value, (char**)NULL);
761 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
762 /*unable to convert given string to floating point parameter*/
763 returnVal=2;
764 dValue=0;
765 }
766 }
767 /* if n > 1 then put 0 values in skipped pages */
768 switch (parameterType) {
769 case SDDS_INT16:
770 if (newPage) {
771 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
772 for (i=2; i<=n; i++)
773 int16Value[page - i] = (int16_t)0;
774 }
775 int16Value[page-1] = (int16_t)iValue;
776 break;
777 case SDDS_UINT16:
778 if (newPage) {
779 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
780 for (i=2; i<=n; i++)
781 uint16Value[page - i] = (uint16_t)0;
782 }
783 uint16Value[page-1] = (uint16_t)iValue;
784 break;
785 case SDDS_INT32:
786 if (newPage) {
787 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
788 for (i=2; i<=n; i++)
789 int32Value[page - i] = (int32_t)0;
790 }
791 int32Value[page-1] = (int32_t)iValue;
792 break;
793 case SDDS_UINT32:
794 if (newPage) {
795 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
796 for (i=2; i<=n; i++)
797 uint32Value[page - i] = (uint32_t)0;
798 }
799 uint32Value[page-1] = (uint32_t)iValue;
800 break;
801 case SDDS_REAL32:
802 if (newPage) {
803 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
804 for (i=2; i<=n; i++)
805 real32Value[page - i] = (float)0;
806 }
807 real32Value[page-1] = (float)dValue;
808 break;
809 case SDDS_REAL64:
810 if (newPage) {
811 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
812 for (i=2; i<=n; i++)
813 real64Value[page - i] = (double)0;
814 }
815 real64Value[page-1] = (double)dValue;
816 break;
817 case SDDS_STRING:
818 if (newPage) {
819 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
820 for (i=2; i<=n; i++)
821 stringValue[page - i] = NULL;
822 }
823 stringValue[page-1] = (char*)SDDS_malloc(sizeof(char) * strlen(value) + 1);
824 strcpy(stringValue[page-1], value);
825 break;
826 case SDDS_CHARACTER:
827 if (newPage) {
828 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
829 for (i=2; i<=n; i++)
830 charValue[page - i] = 0;
831 }
832 charValue[page-1] = value[0];
833 break;
834 default:
835 return(3);
836 }
837 if (newPage)
838 pageCount = page;
839 return(returnVal);
840}
841
842/***********************************************************************************************
843 * readAsciiValue *
844 * *
845 * C++ Arguments: char *value, uint32_t page *
846 * *
847 * Results: 0 for success *
848 * 1 for failure *
849 ***********************************************************************************************/
850int32_t SDDSParameter::readAsciiValue(char **bigBuffer, int32_t *bigBufferSize, uint32_t page) {
851 int32_t returnVal=0, length;
852 uint32_t p;
853 int64_t iValue=0;
854 double dValue=0;
855 static char *buffer=NULL;
856 static int32_t bufferSize=0;
857 if (fixed) {
858 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--parameter is fixed (SDDSParameter::readAsciiValue)");
859 return(1);
860 }
861 if (page == 0) {
862 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--invalid page number (SDDSParameter::readAsciiValue)");
863 return(1);
864 }
865 if (page - 1 != pageCount) {
866 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--invalid page number (SDDSParameter::readAsciiValue)");
867 return(1);
868 }
869 if (bufferSize==0) {
870 bufferSize=SDDS_MAXLINE;
871 buffer = (char*)SDDS_malloc(sizeof(*buffer)*(bufferSize));
872 }
873 if (bufferSize <= *bigBufferSize) {
874 bufferSize = 2 * *bigBufferSize;
875 buffer = (char*)SDDS_realloc(buffer, sizeof(*buffer)*(bufferSize));
876 }
877
878 if (SDDS_INTEGER_TYPE(parameterType)) {
879 if (SDDS_getToken(bigBuffer, bigBufferSize, buffer, bufferSize) < 0) {
880 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter (SDDSParameter::readAsciiValue)");
881 returnVal=1;
882 iValue=0;
883 } else {
884 iValue = strtoll(buffer, (char**)NULL, 10);
885 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
886 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--not a valid integer (SDDSParameter::readAsciiValue)");
887 returnVal=1;
888 iValue=0;
889 }
890 }
891 } else if (SDDS_FLOATING_TYPE(parameterType)) {
892 if (SDDS_getToken(bigBuffer, bigBufferSize, buffer, bufferSize) < 0) {
893 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter (SDDSParameter::readAsciiValue)");
894 returnVal=1;
895 dValue=0;
896 } else {
897 dValue = strtod(buffer, (char**)NULL);
898 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
899 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--not a valid number (SDDSParameter::readAsciiValue)");
900 returnVal=1;
901 dValue=0;
902 }
903 }
904 }
905 p = page - 1;
906 switch (parameterType) {
907 case SDDS_INT16:
908 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
909 int16Value[p] = (int16_t)iValue;
910 break;
911 case SDDS_UINT16:
912 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
913 uint16Value[p] = (uint16_t)iValue;
914 break;
915 case SDDS_INT32:
916 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
917 int32Value[p] = (int32_t)iValue;
918 break;
919 case SDDS_UINT32:
920 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
921 uint32Value[p] = (uint32_t)iValue;
922 break;
923 case SDDS_REAL32:
924 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
925 real32Value[p] = (float)dValue;
926 break;
927 case SDDS_REAL64:
928 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
929 real64Value[p] = (double)dValue;
930 break;
931 case SDDS_STRING:
932 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
933 length = strlen(*bigBuffer);
934 if (length > 0) {
935 if ((*bigBuffer)[length-1] == '\r') {
936 (*bigBuffer)[length-1] = 0;
937 }
938 }
939 if (SDDS_getToken(bigBuffer, bigBufferSize, buffer, bufferSize) < 0) {
940 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter (SDDSParameter::readAsciiValue)");
941 returnVal=1;
942 stringValue[p] = (char*)SDDS_malloc(sizeof(char) * 4);
943 strcpy(stringValue[p], "\"\"");
944 } else {
945 SDDS_interpretEscapes(buffer);
946 stringValue[p] = (char*)SDDS_malloc(sizeof(char) * strlen(buffer) + 1);
947 strcpy(stringValue[p], buffer);
948 }
949 break;
950 case SDDS_CHARACTER:
951 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
952 if (SDDS_getToken(bigBuffer, bigBufferSize, buffer, bufferSize) < 0) {
953 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter (SDDSParameter::readAsciiValue)");
954 returnVal=1;
955 charValue[p] = '-';
956 } else {
957 charValue[p] = buffer[0];
958 }
959 break;
960 default:
961 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--invalid parameter type (SDDSParameter::readAsciiValue)");
962 return(1);
963 }
964 pageCount = page;
965 return(returnVal);
966}
967
968/***********************************************************************************************
969 * getValueInInt32 *
970 * *
971 * C++ Arguments: uint32_t page, int32_t *errorcode *
972 * *
973 * Results: value and errorcode=0 for success *
974 * LONG_MAX and errorcode=1 for parameter value undefined *
975 * LONG_MAX and errorcode=2 for the case where the value cannot be *
976 * converted to the proper type *
977 * LONG_MAX and errorcode=3 for invalid parameter type *
978 ***********************************************************************************************/
979int32_t SDDSParameter::getValueInInt32(uint32_t page, int32_t *errorcode) {
980 int64_t iValue;
981 double dValue;
982 if ((page == 0) || (page > pageCount)) {
983 if (!fixed) {
984 /*parameter value undefined*/
985 *errorcode = 1;
986 return((int32_t)LONG_MAX);
987 }
988 }
989 *errorcode = 0;
990 if (fixed) {
991 if ((SDDS_INTEGER_TYPE(parameterType)) ||
992 (parameterType == SDDS_STRING) ||
993 (parameterType == SDDS_CHARACTER)) {
994 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
995 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
996 /*unable to convert fixed value string to integer*/
997 *errorcode = 2;
998 return((int32_t)LONG_MAX);
999 }
1000 return((int32_t)iValue);
1001 } else if (SDDS_FLOATING_TYPE(parameterType)) {
1002 dValue = strtod(parameterFixedValue, (char**)NULL);
1003 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1004 /*unable to convert fixed value string to floating point*/
1005 *errorcode = 2;
1006 return((int32_t)LONG_MAX);
1007 }
1008 return((int32_t)dValue);
1009 }
1010 }
1011 page--;
1012 switch (parameterType) {
1013 case SDDS_INT16:
1014 return((int32_t)int16Value[page]);
1015 case SDDS_UINT16:
1016 return((int32_t)uint16Value[page]);
1017 case SDDS_INT32:
1018 return((int32_t)int32Value[page]);
1019 case SDDS_UINT32:
1020 return((int32_t)uint32Value[page]);
1021 case SDDS_REAL32:
1022 return((int32_t)real32Value[page]);
1023 case SDDS_REAL64:
1024 return((int32_t)real64Value[page]);
1025 case SDDS_STRING:
1026 iValue = strtoll(stringValue[page], (char**)NULL, 10);
1027 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1028 /*unable to convert string to integer*/
1029 *errorcode = 2;
1030 return((int32_t)LONG_MAX);
1031 }
1032 return((int32_t)iValue);
1033 case SDDS_CHARACTER:
1034 return((int32_t)charValue[page]);
1035 default:
1036 *errorcode = 3;
1037 return((int32_t)LONG_MAX);
1038 }
1039}
1040
1041/***********************************************************************************************
1042 * getValuesInInt32 *
1043 * *
1044 * C++ Arguments: int32_t *errorcode *
1045 * *
1046 * Results: pointer to values and errorcode=0 for success *
1047 * NULL and errorcode=1 for parameter value undefined *
1048 * NULL and errorcode=2 for the case where the value cannot be *
1049 * converted to the proper type *
1050 * NULL and errorcode=3 for invalid parameter type *
1051 ***********************************************************************************************/
1052int32_t* SDDSParameter::getValuesInInt32(int32_t *errorcode) {
1053 int64_t iValue;
1054 double dValue;
1055 int32_t* rValues;
1056 uint32_t i;
1057 if (pageCount == 0) {
1058 if (!fixed) {
1059 /*parameter value undefined*/
1060 *errorcode = 1;
1061 return((int32_t*)NULL);
1062 }
1063 }
1064 *errorcode = 0;
1065 rValues = (int32_t*)SDDS_malloc(sizeof(int32_t) * pageCount);
1066 if (fixed) {
1067 if ((SDDS_INTEGER_TYPE(parameterType)) ||
1068 (parameterType == SDDS_STRING) ||
1069 (parameterType == SDDS_CHARACTER)) {
1070 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
1071 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1072 /*unable to convert fixed value string to integer*/
1073 *errorcode = 2;
1074 SDDS_free(rValues);
1075 return((int32_t*)NULL);
1076 }
1077 for (i=0; i<pageCount; i++)
1078 rValues[i] = (int32_t)iValue;
1079 return((int32_t*)rValues);
1080 } else if (SDDS_FLOATING_TYPE(parameterType)) {
1081 dValue = strtod(parameterFixedValue, (char**)NULL);
1082 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1083 /*unable to convert fixed value string to floating point*/
1084 *errorcode = 2;
1085 SDDS_free(rValues);
1086 return((int32_t*)NULL);
1087 }
1088 for (i=0; i<pageCount; i++)
1089 rValues[i] = (int32_t)dValue;
1090 return((int32_t*)rValues);
1091 }
1092 }
1093 switch (parameterType) {
1094 case SDDS_INT16:
1095 for (i=0; i<pageCount; i++)
1096 rValues[i] = (int32_t)int16Value[i];
1097 return((int32_t*)rValues);
1098 case SDDS_UINT16:
1099 for (i=0; i<pageCount; i++)
1100 rValues[i] = (int32_t)uint16Value[i];
1101 return((int32_t*)rValues);
1102 case SDDS_INT32:
1103 for (i=0; i<pageCount; i++)
1104 rValues[i] = (int32_t)int32Value[i];
1105 return((int32_t*)rValues);
1106 case SDDS_UINT32:
1107 for (i=0; i<pageCount; i++)
1108 rValues[i] = (int32_t)uint32Value[i];
1109 return((int32_t*)rValues);
1110 case SDDS_REAL32:
1111 for (i=0; i<pageCount; i++)
1112 rValues[i] = (int32_t)real32Value[i];
1113 return((int32_t*)rValues);
1114 case SDDS_REAL64:
1115 for (i=0; i<pageCount; i++)
1116 rValues[i] = (int32_t)real64Value[i];
1117 return((int32_t*)rValues);
1118 case SDDS_STRING:
1119 for (i=0; i<pageCount; i++) {
1120 iValue = strtoll(stringValue[i], (char**)NULL, 10);
1121 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1122 /*unable to convert fixed value string to integer*/
1123 *errorcode = 2;
1124 SDDS_free(rValues);
1125 return((int32_t*)NULL);
1126 }
1127 rValues[i] = (int32_t)iValue;
1128 }
1129 return((int32_t*)rValues);
1130 case SDDS_CHARACTER:
1131 for (i=0; i<pageCount; i++)
1132 rValues[i] = (int32_t)charValue[i];
1133 return((int32_t*)rValues);
1134 default:
1135 *errorcode = 3;
1136 return((int32_t*)NULL);
1137 }
1138}
1139
1140/***********************************************************************************************
1141 * getValueInUInt32 *
1142 * *
1143 * C++ Arguments: uint32_t page, int32_t *errorcode *
1144 * *
1145 * Results: value and errorcode=0 for success *
1146 * ULONG_MAX and errorcode=1 for parameter value undefined *
1147 * ULONG_MAX and errorcode=2 for the case where the value cannot be *
1148 * converted to the proper type *
1149 * ULONG_MAX and errorcode=3 for invalid parameter type *
1150 ***********************************************************************************************/
1151uint32_t SDDSParameter::getValueInUInt32(uint32_t page, int32_t *errorcode) {
1152 int64_t iValue;
1153 double dValue;
1154 if ((page == 0) || (page > pageCount)) {
1155 if (!fixed) {
1156 /*parameter value undefined*/
1157 *errorcode = 1;
1158 return((uint32_t)ULONG_MAX);
1159 }
1160 }
1161 *errorcode = 0;
1162 if (fixed) {
1163 if ((SDDS_INTEGER_TYPE(parameterType)) ||
1164 (parameterType == SDDS_STRING) ||
1165 (parameterType == SDDS_CHARACTER)) {
1166 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
1167 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1168 /*unable to convert fixed value string to integer*/
1169 *errorcode = 2;
1170 return((uint32_t)ULONG_MAX);
1171 }
1172 return((uint32_t)iValue);
1173 } else if (SDDS_FLOATING_TYPE(parameterType)) {
1174 dValue = strtod(parameterFixedValue, (char**)NULL);
1175 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1176 /*unable to convert fixed value string to floating point*/
1177 *errorcode = 2;
1178 return((uint32_t)ULONG_MAX);
1179 }
1180 return((uint32_t)dValue);
1181 }
1182 }
1183 page--;
1184 switch (parameterType) {
1185 case SDDS_INT16:
1186 return((uint32_t)int16Value[page]);
1187 case SDDS_UINT16:
1188 return((uint32_t)uint16Value[page]);
1189 case SDDS_INT32:
1190 return((uint32_t)int32Value[page]);
1191 case SDDS_UINT32:
1192 return((uint32_t)uint32Value[page]);
1193 case SDDS_REAL32:
1194 return((uint32_t)real32Value[page]);
1195 case SDDS_REAL64:
1196 return((uint32_t)real64Value[page]);
1197 case SDDS_STRING:
1198 iValue = strtoll(stringValue[page], (char**)NULL, 10);
1199 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1200 /*unable to convert string to integer*/
1201 *errorcode = 2;
1202 return((uint32_t)ULONG_MAX);
1203 }
1204 return((uint32_t)iValue);
1205 case SDDS_CHARACTER:
1206 return((uint32_t)charValue[page]);
1207 default:
1208 *errorcode = 3;
1209 return((uint32_t)ULONG_MAX);
1210 }
1211}
1212
1213/***********************************************************************************************
1214 * getValuesInUInt32 *
1215 * *
1216 * C++ Arguments: int32_t *errorcode *
1217 * *
1218 * Results: pointer to values and errorcode=0 for success *
1219 * NULL and errorcode=1 for parameter value undefined *
1220 * NULL and errorcode=2 for the case where the value cannot be *
1221 * converted to the proper type *
1222 * NULL and errorcode=3 for invalid parameter type *
1223 ***********************************************************************************************/
1224uint32_t* SDDSParameter::getValuesInUInt32(int32_t *errorcode) {
1225 int64_t iValue;
1226 double dValue;
1227 uint32_t* rValues;
1228 uint32_t i;
1229 if (pageCount == 0) {
1230 if (!fixed) {
1231 /*parameter value undefined*/
1232 *errorcode = 1;
1233 return((uint32_t*)NULL);
1234 }
1235 }
1236 *errorcode = 0;
1237 rValues = (uint32_t*)SDDS_malloc(sizeof(uint32_t) * pageCount);
1238 if (fixed) {
1239 if ((SDDS_INTEGER_TYPE(parameterType)) ||
1240 (parameterType == SDDS_STRING) ||
1241 (parameterType == SDDS_CHARACTER)) {
1242 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
1243 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1244 /*unable to convert fixed value string to integer*/
1245 *errorcode = 2;
1246 SDDS_free(rValues);
1247 return((uint32_t*)NULL);
1248 }
1249 for (i=0; i<pageCount; i++)
1250 rValues[i] = (uint32_t)iValue;
1251 return((uint32_t*)rValues);
1252 } else if (SDDS_FLOATING_TYPE(parameterType)) {
1253 dValue = strtod(parameterFixedValue, (char**)NULL);
1254 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1255 /*unable to convert fixed value string to floating point*/
1256 *errorcode = 2;
1257 SDDS_free(rValues);
1258 return((uint32_t*)NULL);
1259 }
1260 for (i=0; i<pageCount; i++)
1261 rValues[i] = (uint32_t)dValue;
1262 return((uint32_t*)rValues);
1263 }
1264 }
1265 switch (parameterType) {
1266 case SDDS_INT16:
1267 for (i=0; i<pageCount; i++)
1268 rValues[i] = (uint32_t)int16Value[i];
1269 return((uint32_t*)rValues);
1270 case SDDS_UINT16:
1271 for (i=0; i<pageCount; i++)
1272 rValues[i] = (uint32_t)uint16Value[i];
1273 return((uint32_t*)rValues);
1274 case SDDS_INT32:
1275 for (i=0; i<pageCount; i++)
1276 rValues[i] = (uint32_t)int32Value[i];
1277 return((uint32_t*)rValues);
1278 case SDDS_UINT32:
1279 for (i=0; i<pageCount; i++)
1280 rValues[i] = (uint32_t)uint32Value[i];
1281 return((uint32_t*)rValues);
1282 case SDDS_REAL32:
1283 for (i=0; i<pageCount; i++)
1284 rValues[i] = (uint32_t)real32Value[i];
1285 return((uint32_t*)rValues);
1286 case SDDS_REAL64:
1287 for (i=0; i<pageCount; i++)
1288 rValues[i] = (uint32_t)real64Value[i];
1289 return((uint32_t*)rValues);
1290 case SDDS_STRING:
1291 for (i=0; i<pageCount; i++) {
1292 iValue = strtoll(stringValue[i], (char**)NULL, 10);
1293 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1294 /*unable to convert fixed value string to integer*/
1295 *errorcode = 2;
1296 SDDS_free(rValues);
1297 return((uint32_t*)NULL);
1298 }
1299 rValues[i] = (uint32_t)iValue;
1300 }
1301 return((uint32_t*)rValues);
1302 case SDDS_CHARACTER:
1303 for (i=0; i<pageCount; i++)
1304 rValues[i] = (uint32_t)charValue[i];
1305 return((uint32_t*)rValues);
1306 default:
1307 *errorcode = 3;
1308 return((uint32_t*)NULL);
1309 }
1310}
1311
1312/***********************************************************************************************
1313 * getValueInDouble *
1314 * *
1315 * C++ Arguments: uint32_t page, int32_t *errorcode *
1316 * *
1317 * Results: value and errorcode=0 for success *
1318 * HUGE_VAL and errorcode=1 for parameter value undefined *
1319 * HUGE_VAL and errorcode=2 for the case where the value cannot be *
1320 * converted to the proper type *
1321 * HUGE_VAL and errorcode=3 for invalid parameter type *
1322 ***********************************************************************************************/
1323double SDDSParameter::getValueInDouble(uint32_t page, int32_t *errorcode) {
1324 int64_t iValue;
1325 double dValue;
1326 if ((page == 0) || (page > pageCount)) {
1327 if (!fixed) {
1328 /*parameter value undefined*/
1329 *errorcode = 1;
1330 return((double)HUGE_VAL);
1331 }
1332 }
1333 *errorcode = 0;
1334 if (fixed) {
1335 if ((SDDS_INTEGER_TYPE(parameterType)) ||
1336 (parameterType == SDDS_CHARACTER)) {
1337 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
1338 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1339 /*unable to convert fixed value string to integer*/
1340 *errorcode = 2;
1341 return((double)HUGE_VAL);
1342 }
1343 return((double)iValue);
1344 } else if ((SDDS_FLOATING_TYPE(parameterType)) ||
1345 (parameterType == SDDS_STRING)) {
1346 dValue = strtod(parameterFixedValue, (char**)NULL);
1347 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1348 /*unable to convert fixed value string to floating point*/
1349 *errorcode = 2;
1350 return((double)HUGE_VAL);
1351 }
1352 return((double)dValue);
1353 }
1354 }
1355 page--;
1356 switch (parameterType) {
1357 case SDDS_INT16:
1358 return((double)int16Value[page]);
1359 case SDDS_UINT16:
1360 return((double)uint16Value[page]);
1361 case SDDS_INT32:
1362 return((double)int32Value[page]);
1363 case SDDS_UINT32:
1364 return((double)uint32Value[page]);
1365 case SDDS_REAL32:
1366 return((double)real32Value[page]);
1367 case SDDS_REAL64:
1368 return((double)real64Value[page]);
1369 case SDDS_STRING:
1370 dValue = strtod(stringValue[page], (char**)NULL);
1371 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1372 /*unable to convert string to floating point*/
1373 *errorcode = 2;
1374 return((double)HUGE_VAL);
1375 }
1376 return((double)dValue);
1377 case SDDS_CHARACTER:
1378 return((double)charValue[page]);
1379 default:
1380 *errorcode = 3;
1381 return((double)HUGE_VAL);
1382 }
1383}
1384
1385/***********************************************************************************************
1386 * getValuesInDouble *
1387 * *
1388 * C++ Arguments: int32_t *errorcode *
1389 * *
1390 * Results: pointer to values and errorcode=0 for success *
1391 * NULL and errorcode=1 for parameter value undefined *
1392 * NULL and errorcode=2 for the case where the value cannot be *
1393 * converted to the proper type *
1394 * NULL and errorcode=3 for invalid parameter type *
1395 ***********************************************************************************************/
1396double* SDDSParameter::getValuesInDouble(int32_t *errorcode) {
1397 int64_t iValue;
1398 double dValue;
1399 double* rValues;
1400 uint32_t i;
1401 if (pageCount == 0) {
1402 if (!fixed) {
1403 /*parameter value undefined*/
1404 *errorcode = 1;
1405 return((double*)NULL);
1406 }
1407 }
1408 *errorcode = 0;
1409 rValues = (double*)SDDS_malloc(sizeof(double) * pageCount);
1410 if (fixed) {
1411 if ((SDDS_INTEGER_TYPE(parameterType)) ||
1412 (parameterType == SDDS_CHARACTER)) {
1413 iValue = strtoll(parameterFixedValue, (char**)NULL, 10);
1414 if ((iValue == LLONG_MIN) || (iValue == LLONG_MAX)) {
1415 /*unable to convert fixed value string to integer*/
1416 *errorcode = 2;
1417 SDDS_free(rValues);
1418 return((double*)NULL);
1419 }
1420 for (i=0; i<pageCount; i++)
1421 rValues[i] = (double)iValue;
1422 return((double*)rValues);
1423 } else if ((SDDS_FLOATING_TYPE(parameterType)) ||
1424 (parameterType == SDDS_STRING)) {
1425 dValue = strtod(parameterFixedValue, (char**)NULL);
1426 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1427 /*unable to convert fixed value string to floating point*/
1428 *errorcode = 2;
1429 SDDS_free(rValues);
1430 return((double*)NULL);
1431 }
1432 for (i=0; i<pageCount; i++)
1433 rValues[i] = (double)dValue;
1434 return((double*)rValues);
1435 }
1436 }
1437 switch (parameterType) {
1438 case SDDS_INT16:
1439 for (i=0; i<pageCount; i++)
1440 rValues[i] = (double)int16Value[i];
1441 return((double*)rValues);
1442 case SDDS_UINT16:
1443 for (i=0; i<pageCount; i++)
1444 rValues[i] = (double)uint16Value[i];
1445 return((double*)rValues);
1446 case SDDS_INT32:
1447 for (i=0; i<pageCount; i++)
1448 rValues[i] = (double)int32Value[i];
1449 return((double*)rValues);
1450 case SDDS_UINT32:
1451 for (i=0; i<pageCount; i++)
1452 rValues[i] = (double)uint32Value[i];
1453 return((double*)rValues);
1454 case SDDS_REAL32:
1455 for (i=0; i<pageCount; i++)
1456 rValues[i] = (double)real32Value[i];
1457 return((double*)rValues);
1458 case SDDS_REAL64:
1459 for (i=0; i<pageCount; i++)
1460 rValues[i] = (double)real64Value[i];
1461 return((double*)rValues);
1462 case SDDS_STRING:
1463 for (i=0; i<pageCount; i++) {
1464 dValue = strtod(stringValue[i], (char**)NULL);
1465 if ((dValue == HUGE_VAL) || (dValue == -HUGE_VAL)) {
1466 /*unable to convert fixed value string to floating point*/
1467 *errorcode = 2;
1468 SDDS_free(rValues);
1469 return((double*)NULL);
1470 }
1471 rValues[i] = (double)dValue;
1472 }
1473 return((double*)rValues);
1474 case SDDS_CHARACTER:
1475 for (i=0; i<pageCount; i++)
1476 rValues[i] = (double)charValue[i];
1477 return((double*)rValues);
1478 default:
1479 *errorcode = 3;
1480 return((double*)NULL);
1481 }
1482}
1483
1484/***********************************************************************************************
1485 * getValueInString *
1486 * *
1487 * C++ Arguments: uint32_t page, int32_t *errorcode *
1488 * *
1489 * Results: value and errorcode=0 for success (You will have to free the value yourself) *
1490 * NULL and errorcode=1 for parameter value undefined *
1491 * NULL and errorcode=2 for the case where the value cannot be *
1492 * converted to the proper type *
1493 * NULL and errorcode=3 for invalid parameter type *
1494 ***********************************************************************************************/
1495char* SDDSParameter::getValueInString(uint32_t page, int32_t *errorcode) {
1496 char *sValue;
1497 char s[SDDS_MAXLINE];
1498 if ((page == 0) || (page > pageCount)) {
1499 if (!fixed) {
1500 /*parameter value undefined*/
1501 *errorcode = 1;
1502 return((char*)NULL);
1503 }
1504 }
1505 *errorcode = 0;
1506 if (fixed) {
1507 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(parameterFixedValue) + 1);
1508 strcpy(sValue, parameterFixedValue);
1509 return((char*)sValue);
1510 }
1511 page--;
1512 switch (parameterType) {
1513 case SDDS_INT16:
1514 sprintf(s, "%" PRId16, int16Value[page]);
1515 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1516 strcpy(sValue, s);
1517 return((char*)sValue);
1518 case SDDS_UINT16:
1519 sprintf(s, "%" PRIu16, uint16Value[page]);
1520 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1521 strcpy(sValue, s);
1522 return((char*)sValue);
1523 case SDDS_INT32:
1524 sprintf(s, "%" PRId32, int32Value[page]);
1525 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1526 strcpy(sValue, s);
1527 return((char*)sValue);
1528 case SDDS_UINT32:
1529 sprintf(s, "%" PRIu32, uint32Value[page]);
1530 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1531 strcpy(sValue, s);
1532 return((char*)sValue);
1533 case SDDS_REAL32:
1534 sprintf(s, "%f", real32Value[page]);
1535 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1536 strcpy(sValue, s);
1537 return((char*)sValue);
1538 case SDDS_REAL64:
1539 sprintf(s, "%lf", real64Value[page]);
1540 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1541 strcpy(sValue, s);
1542 return((char*)sValue);
1543 case SDDS_STRING:
1544 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(stringValue[page]) + 1);
1545 strcpy(sValue, stringValue[page]);
1546 return((char*)sValue);
1547 case SDDS_CHARACTER:
1548 sprintf(s, "%c", charValue[page]);
1549 sValue = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1550 strcpy(sValue, s);
1551 return((char*)sValue);
1552 default:
1553 *errorcode = 3;
1554 return((char*)NULL);
1555 }
1556}
1557
1558/***********************************************************************************************
1559 * getValuesInString *
1560 * *
1561 * C++ Arguments: int32_t *errorcode *
1562 * *
1563 * Results: pointer to values and errorcode=0 for success *
1564 * NULL and errorcode=1 for parameter value undefined *
1565 * NULL and errorcode=2 for the case where the value cannot be *
1566 * converted to the proper type *
1567 * NULL and errorcode=3 for invalid parameter type *
1568 ***********************************************************************************************/
1569char** SDDSParameter::getValuesInString(int32_t *errorcode) {
1570 char** rValues;
1571 uint32_t i;
1572 char s[SDDS_MAXLINE];
1573 if (pageCount == 0) {
1574 if (!fixed) {
1575 /*parameter value undefined*/
1576 *errorcode = 1;
1577 return((char**)NULL);
1578 }
1579 }
1580 *errorcode = 0;
1581 rValues = (char**)SDDS_malloc(sizeof(char*) * pageCount);
1582 if (fixed) {
1583 for (i=0; i<pageCount; i++) {
1584 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(parameterFixedValue) + 1);
1585 strcpy(rValues[i], parameterFixedValue);
1586 }
1587 return((char**)rValues);
1588 }
1589 switch (parameterType) {
1590 case SDDS_INT16:
1591 for (i=0; i<pageCount; i++) {
1592 sprintf(s, "%" PRId16, int16Value[i]);
1593 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1594 strcpy(rValues[i], s);
1595 }
1596 return((char**)rValues);
1597 case SDDS_UINT16:
1598 for (i=0; i<pageCount; i++) {
1599 sprintf(s, "%" PRIu16, uint16Value[i]);
1600 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1601 strcpy(rValues[i], s);
1602 }
1603 return((char**)rValues);
1604 case SDDS_INT32:
1605 for (i=0; i<pageCount; i++) {
1606 sprintf(s, "%" PRId32, int32Value[i]);
1607 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1608 strcpy(rValues[i], s);
1609 }
1610 return((char**)rValues);
1611 case SDDS_UINT32:
1612 for (i=0; i<pageCount; i++) {
1613 sprintf(s, "%" PRIu32, uint32Value[i]);
1614 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1615 strcpy(rValues[i], s);
1616 }
1617 return((char**)rValues);
1618 case SDDS_REAL32:
1619 for (i=0; i<pageCount; i++) {
1620 sprintf(s, "%f", real32Value[i]);
1621 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1622 strcpy(rValues[i], s);
1623 }
1624 return((char**)rValues);
1625 case SDDS_REAL64:
1626 for (i=0; i<pageCount; i++) {
1627 sprintf(s, "%lf", real64Value[i]);
1628 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1629 strcpy(rValues[i], s);
1630 }
1631 return((char**)rValues);
1632 case SDDS_STRING:
1633 for (i=0; i<pageCount; i++) {
1634 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(stringValue[i]) + 1);
1635 strcpy(rValues[i], stringValue[i]);
1636 }
1637 return((char**)rValues);
1638 case SDDS_CHARACTER:
1639 for (i=0; i<pageCount; i++) {
1640 sprintf(s, "%c", charValue[i]);
1641 rValues[i] = (char*)SDDS_malloc(sizeof(char) * strlen(s) + 1);
1642 strcpy(rValues[i], s);
1643 }
1644 return((char**)rValues);
1645 default:
1646 *errorcode = 3;
1647 return((char**)NULL);
1648 }
1649}
1650
1651/***********************************************************************************************
1652 * writeDefinition *
1653 * *
1654 * C++ Arguments: FILE *fp *
1655 * voidp *gzfp *
1656 * *
1657 * Results: 0 on success *
1658 * 1 on failure *
1659 ***********************************************************************************************/
1660int32_t SDDSParameter::writeDefinition(FILE *fp) {
1661 if ((parameterType <= 0) || (parameterType > SDDS_NUM_TYPES)) {
1662 return(1);
1663 }
1664 if (fp == NULL) {
1665 return(1);
1666 }
1667 fputs("&parameter ", fp);
1668 if (SDDS_printNamelistField(fp, (char*)"name", parameterName)) {
1669 return(1);
1670 }
1671 if (SDDS_printNamelistField(fp, (char*)"symbol", SDDS_blankToNull(parameterSymbol))) {
1672 return(1);
1673 }
1674 if (SDDS_printNamelistField(fp, (char*)"units", SDDS_blankToNull(parameterUnits))) {
1675 return(1);
1676 }
1677 if (SDDS_printNamelistField(fp, (char*)"description", SDDS_blankToNull(parameterDescription))) {
1678 return(1);
1679 }
1680 if (SDDS_printNamelistField(fp, (char*)"format_string", SDDS_blankToNull(parameterFormatString))) {
1681 return(1);
1682 }
1683 if (((SDDSFile*)sddsfile)->layoutVersion == 1) {
1684 if (SDDS_printNamelistField(fp, (char*)"type", SDDS_getVer1TypeName(parameterType))) {
1685 return(1);
1686 }
1687 } else if (((SDDSFile*)sddsfile)->layoutVersion == 2) {
1688 if (SDDS_printNamelistField(fp, (char*)"type", SDDS_getVer2TypeName(parameterType))) {
1689 return(1);
1690 }
1691 } else {
1692 if (SDDS_printNamelistField(fp, (char*)"type", SDDS_getTypeName(parameterType))) {
1693 return(1);
1694 }
1695 }
1696 if (SDDS_printNamelistField(fp, (char*)"fixed_value", parameterFixedValue)) {
1697 return(1);
1698 }
1699 fputs("&end\n", fp);
1700 return(0);
1701}
1702
1703int32_t SDDSParameter::writeDefinition(voidp *gzfp) {
1704 if ((parameterType <= 0) || (parameterType > SDDS_NUM_TYPES)) {
1705 return(1);
1706 }
1707 if (gzfp == NULL) {
1708 return(1);
1709 }
1710 gzputs(gzfp, "&parameter ");
1711 if (SDDS_printNamelistField(gzfp, (char*)"name", parameterName)) {
1712 return(1);
1713 }
1714 if (SDDS_printNamelistField(gzfp, (char*)"symbol", SDDS_blankToNull(parameterSymbol))) {
1715 return(1);
1716 }
1717 if (SDDS_printNamelistField(gzfp, (char*)"units", SDDS_blankToNull(parameterUnits))) {
1718 return(1);
1719 }
1720 if (SDDS_printNamelistField(gzfp, (char*)"description", SDDS_blankToNull(parameterDescription))) {
1721 return(1);
1722 }
1723 if (SDDS_printNamelistField(gzfp, (char*)"format_string", SDDS_blankToNull(parameterFormatString))) {
1724 return(1);
1725 }
1726 if (((SDDSFile*)sddsfile)->layoutVersion == 1) {
1727 if (SDDS_printNamelistField(gzfp, (char*)"type", SDDS_getVer1TypeName(parameterType))) {
1728 return(1);
1729 }
1730 } else if (((SDDSFile*)sddsfile)->layoutVersion == 2) {
1731 if (SDDS_printNamelistField(gzfp, (char*)"type", SDDS_getVer2TypeName(parameterType))) {
1732 return(1);
1733 }
1734 } else {
1735 if (SDDS_printNamelistField(gzfp, (char*)"type", SDDS_getTypeName(parameterType))) {
1736 return(1);
1737 }
1738 }
1739 if (SDDS_printNamelistField(gzfp, (char*)"fixed_value", parameterFixedValue)) {
1740 return(1);
1741 }
1742 gzputs(gzfp, "&end\n");
1743 return(0);
1744}
1745
1746/***********************************************************************************************
1747 * writeAsciiValue *
1748 * *
1749 * C++ Arguments: FILE *fp, uint32_t page *
1750 * C++ Arguments: voidp *gzfp, uint32_t page *
1751 * *
1752 * Results: 0 on success *
1753 * 1 on failure *
1754 ***********************************************************************************************/
1755int32_t SDDSParameter::writeAsciiValue(FILE *fp, uint32_t page) {
1756 char c;
1757 char *s;
1758 int32_t hasWhitespace;
1759
1760 if (fixed) {
1761 return(0);
1762 }
1763 if ((page == 0) || (page > pageCount)) {
1764 return(1);
1765 }
1766 page--;
1767 switch (parameterType) {
1768 case SDDS_INT16:
1769 fprintf(fp, "%" PRId16 "\n", int16Value[page]);
1770 break;
1771 case SDDS_UINT16:
1772 fprintf(fp, "%" PRIu16 "\n", uint16Value[page]);
1773 break;
1774 case SDDS_INT32:
1775 fprintf(fp, "%" PRId32 "\n", int32Value[page]);
1776 break;
1777 case SDDS_UINT32:
1778 fprintf(fp, "%" PRIu32 "\n", uint32Value[page]);
1779 break;
1780 case SDDS_REAL32:
1781 fprintf(fp, "%.*g\n", FLT_DIG, real32Value[page]);
1782 break;
1783 case SDDS_REAL64:
1784 fprintf(fp, "%.*g\n", DBL_DIG, real64Value[page]);
1785 break;
1786 case SDDS_STRING:
1787 s = stringValue[page];
1788 hasWhitespace=0;
1789 if (SDDS_hasWhitespace(s) || SDDS_stringIsBlank(s)) {
1790 fputc('"', fp);
1791 hasWhitespace = 1;
1792 }
1793 while (s && *s) {
1794 c = *s++;
1795 if (c=='!') {
1796 fputs("\\!", fp);
1797 } else if (c=='\\') {
1798 fputs("\\\\", fp);
1799 } else if (c=='"') {
1800 fputs("\\\"", fp);
1801 } else if (c==' ') {
1802 fputc(' ', fp); /* don't escape plain spaces */
1803 } else if (isspace(c) || !isprint(c)) {
1804 fprintf(fp, "\\%03o", c);
1805 } else {
1806 fputc(c, fp);
1807 }
1808 }
1809 if (hasWhitespace) {
1810 fputc('"', fp);
1811 }
1812 fputc('\n', fp);
1813 break;
1814 case SDDS_CHARACTER:
1815 c = charValue[page];
1816 if (c=='!')
1817 fputs("\\!", fp);
1818 else if (c=='\\')
1819 fputs("\\\\", fp);
1820 else if (c=='"')
1821 fputs("\\\"", fp);
1822 else if (!c || isspace(c) || !isprint(c))
1823 fprintf(fp, "\\%03o", c);
1824 else
1825 fputc(c, fp);
1826 fputc('\n', fp);
1827 break;
1828 default:
1829 return(1);
1830 }
1831 return(0);
1832}
1833
1834int32_t SDDSParameter::writeAsciiValue(voidp *gzfp, uint32_t page) {
1835 char c;
1836 char *s;
1837 int32_t hasWhitespace;
1838
1839 if (fixed) {
1840 return(0);
1841 }
1842 if ((page == 0) || (page > pageCount)) {
1843 return(1);
1844 }
1845 page--;
1846 switch (parameterType) {
1847 case SDDS_INT16:
1848 gzprintf(gzfp, "%" PRId16 "\n", int16Value[page]);
1849 break;
1850 case SDDS_UINT16:
1851 gzprintf(gzfp, "%" PRIu16 "\n", uint16Value[page]);
1852 break;
1853 case SDDS_INT32:
1854 gzprintf(gzfp, "%" PRId32 "\n", int32Value[page]);
1855 break;
1856 case SDDS_UINT32:
1857 gzprintf(gzfp, "%" PRIu32 "\n", uint32Value[page]);
1858 break;
1859 case SDDS_REAL32:
1860 gzprintf(gzfp, "%.*g\n", FLT_DIG, real32Value[page]);
1861 break;
1862 case SDDS_REAL64:
1863 gzprintf(gzfp, "%.*g\n", DBL_DIG, real64Value[page]);
1864 break;
1865 case SDDS_STRING:
1866 s = stringValue[page];
1867 hasWhitespace=0;
1868 if (SDDS_hasWhitespace(s) || SDDS_stringIsBlank(s)) {
1869 gzputc(gzfp, '"');
1870 hasWhitespace = 1;
1871 }
1872 while (s && *s) {
1873 c = *s++;
1874 if (c=='!') {
1875 gzputs(gzfp, "\\!");
1876 } else if (c=='\\') {
1877 gzputs(gzfp, "\\\\");
1878 } else if (c=='"') {
1879 gzputs(gzfp, "\\\"");
1880 } else if (c==' ') {
1881 gzputc(gzfp, ' '); /* don't escape plain spaces */
1882 } else if (isspace(c) || !isprint(c)) {
1883 gzprintf(gzfp, "\\%03o", c);
1884 } else {
1885 gzputc(gzfp, c);
1886 }
1887 }
1888 if (hasWhitespace) {
1889 gzputc(gzfp, '"');
1890 }
1891 gzputc(gzfp, '\n');
1892 break;
1893 case SDDS_CHARACTER:
1894 c = charValue[page];
1895 if (c=='!')
1896 gzputs(gzfp, "\\!");
1897 else if (c=='\\')
1898 gzputs(gzfp, "\\\\");
1899 else if (c=='"')
1900 gzputs(gzfp, "\\\"");
1901 else if (!c || isspace(c) || !isprint(c))
1902 gzprintf(gzfp, "\\%03o", c);
1903 else
1904 gzputc(gzfp, c);
1905 gzputc(gzfp, '\n');
1906 break;
1907 default:
1908 return(1);
1909 }
1910 return(0);
1911}
1912
1913/***********************************************************************************************
1914 * writeBinaryValue *
1915 * *
1916 * C++ Arguments: FILE *fp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian *
1917 * C++ Arguments: voidp *gzfp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian *
1918 * *
1919 * Results: 0 on success *
1920 * 1 on failure *
1921 ***********************************************************************************************/
1922int32_t SDDSParameter::writeBinaryValue(FILE *fp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian) {
1923 if (fixed) {
1924 return(0);
1925 }
1926 if ((page == 0) || (page > pageCount)) {
1927 return(1);
1928 }
1929 page--;
1930 switch (parameterType) {
1931 case SDDS_INT16:
1932 if (SDDS_bufferedWrite(&(int16Value[page]), 2, fp, fBuffer, sddsfile)) {
1933 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1934 return(1);
1935 }
1936 break;
1937 case SDDS_UINT16:
1938 if (SDDS_bufferedWrite(&(uint16Value[page]), 2, fp, fBuffer, sddsfile)) {
1939 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1940 return(1);
1941 }
1942 break;
1943 case SDDS_INT32:
1944 if (SDDS_bufferedWrite(&(int32Value[page]), 4, fp, fBuffer, sddsfile)) {
1945 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1946 return(1);
1947 }
1948 break;
1949 case SDDS_UINT32:
1950 if (SDDS_bufferedWrite(&(uint32Value[page]), 4, fp, fBuffer, sddsfile)) {
1951 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1952 return(1);
1953 }
1954 break;
1955 case SDDS_REAL32:
1956 if (SDDS_bufferedWrite(&(real32Value[page]), 4, fp, fBuffer, sddsfile)) {
1957 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1958 return(1);
1959 }
1960 break;
1961 case SDDS_REAL64:
1962 if (SDDS_bufferedWrite(&(real64Value[page]), 8, fp, fBuffer, sddsfile)) {
1963 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1964 return(1);
1965 }
1966 break;
1967 case SDDS_STRING:
1968 if (SDDS_writeBinaryString(stringValue[page], fp, fBuffer, sddsfile)) {
1969 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing string (SDDSParameter::writeBinaryValue)");
1970 return(1);
1971 }
1972 break;
1973 case SDDS_CHARACTER:
1974 if (SDDS_bufferedWrite(&(charValue[page]), 1, fp, fBuffer, sddsfile)) {
1975 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1976 return(1);
1977 }
1978 break;
1979 default:
1980 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--unknown type (SDDSParameter::writeBinaryValue)");
1981 return(1);
1982 }
1983 return(0);
1984}
1985
1986int32_t SDDSParameter::writeBinaryValue(voidp *gzfp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian) {
1987 if (fixed) {
1988 return(0);
1989 }
1990 if ((page == 0) || (page > pageCount)) {
1991 return(1);
1992 }
1993 page--;
1994 switch (parameterType) {
1995 case SDDS_INT16:
1996 if (SDDS_bufferedWrite(&(int16Value[page]), 2, gzfp, fBuffer, sddsfile)) {
1997 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
1998 return(1);
1999 }
2000 break;
2001 case SDDS_UINT16:
2002 if (SDDS_bufferedWrite(&(uint16Value[page]), 2, gzfp, fBuffer, sddsfile)) {
2003 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2004 return(1);
2005 }
2006 break;
2007 case SDDS_INT32:
2008 if (SDDS_bufferedWrite(&(int32Value[page]), 4, gzfp, fBuffer, sddsfile)) {
2009 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2010 return(1);
2011 }
2012 break;
2013 case SDDS_UINT32:
2014 if (SDDS_bufferedWrite(&(uint32Value[page]), 4, gzfp, fBuffer, sddsfile)) {
2015 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2016 return(1);
2017 }
2018 break;
2019 case SDDS_REAL32:
2020 if (SDDS_bufferedWrite(&(real32Value[page]), 4, gzfp, fBuffer, sddsfile)) {
2021 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2022 return(1);
2023 }
2024 break;
2025 case SDDS_REAL64:
2026 if (SDDS_bufferedWrite(&(real64Value[page]), 8, gzfp, fBuffer, sddsfile)) {
2027 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2028 return(1);
2029 }
2030 break;
2031 case SDDS_STRING:
2032 if (SDDS_writeBinaryString(stringValue[page], gzfp, fBuffer, sddsfile)) {
2033 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing string (SDDSParameter::writeBinaryValue)");
2034 return(1);
2035 }
2036 break;
2037 case SDDS_CHARACTER:
2038 if (SDDS_bufferedWrite(&(charValue[page]), 1, gzfp, fBuffer, sddsfile)) {
2039 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--failure writing value (SDDSParameter::writeBinaryValue)");
2040 return(1);
2041 }
2042 break;
2043 default:
2044 ((SDDSFile*)sddsfile)->setError((char*)"Unable to write parameter--unknown type (SDDSParameter::writeBinaryValue)");
2045 return(1);
2046 }
2047 return(0);
2048}
2049
2050/***********************************************************************************************
2051 * readBinaryValue *
2052 * *
2053 * C++ Arguments: FILE *fp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian *
2054 * C++ Arguments: voidp *gzfp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian *
2055 * *
2056 * Results: 0 on success *
2057 * 1 on failure *
2058 ***********************************************************************************************/
2059int32_t SDDSParameter::readBinaryValue(FILE *fp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian) {
2060 uint32_t p;
2061
2062 if (fixed) {
2063 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--parameter is fixed (SDDSParameter::readBinaryValue)");
2064 return(1);
2065 }
2066 if ((page == 0) || (page - 1 != pageCount)) {
2067 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--invalid page number (SDDSParameter::readBinaryValue)");
2068 return(1);
2069 }
2070 p = page - 1;
2071 switch (parameterType) {
2072 case SDDS_INT16:
2073 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
2074 if (SDDS_bufferedRead(&(int16Value[p]), 2, fp, fBuffer, sddsfile)) {
2075 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2076 return(1);
2077 }
2078 break;
2079 case SDDS_UINT16:
2080 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
2081 if (SDDS_bufferedRead(&(uint16Value[p]), 2, fp, fBuffer, sddsfile)) {
2082 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2083 return(1);
2084 }
2085 break;
2086 case SDDS_INT32:
2087 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
2088 if (SDDS_bufferedRead(&(int32Value[p]), 4, fp, fBuffer, sddsfile)) {
2089 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2090 return(1);
2091 }
2092 break;
2093 case SDDS_UINT32:
2094 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
2095 if (SDDS_bufferedRead(&(uint32Value[p]), 4, fp, fBuffer, sddsfile)) {
2096 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2097 return(1);
2098 }
2099 break;
2100 case SDDS_REAL32:
2101 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
2102 if (SDDS_bufferedRead(&(real32Value[p]), 4, fp, fBuffer, sddsfile)) {
2103 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2104 return(1);
2105 }
2106 break;
2107 case SDDS_REAL64:
2108 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
2109 if (SDDS_bufferedRead(&(real64Value[p]), 8, fp, fBuffer, sddsfile)) {
2110 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2111 return(1);
2112 }
2113 break;
2114 case SDDS_STRING:
2115 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
2116 stringValue[p] = NULL;
2117 if (SDDS_readBinaryString(&(stringValue[p]), fp, fBuffer, sddsfile)) {
2118 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading string (SDDSParameter::readBinaryValue)");
2119 return(1);
2120 }
2121 break;
2122 case SDDS_CHARACTER:
2123 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
2124 if (SDDS_bufferedRead(&(charValue[p]), 1, fp, fBuffer, sddsfile)) {
2125 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2126 return(1);
2127 }
2128 break;
2129 default:
2130 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--unknown type (SDDSParameter::readBinaryValue)");
2131 return(1);
2132 }
2133 pageCount = page;
2134 return(0);
2135}
2136
2137int32_t SDDSParameter::readBinaryValue(voidp *gzfp, SDDS_FILEBUFFER *fBuffer, uint32_t page, bool nonNativeEndian) {
2138 uint32_t p;
2139
2140 if (fixed) {
2141 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--parameter is fixed (SDDSParameter::readBinaryValue)");
2142 return(1);
2143 }
2144 if ((page == 0) || (page - 1 != pageCount)) {
2145 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--invalid page number (SDDSParameter::readBinaryValue)");
2146 return(1);
2147 }
2148 p = page - 1;
2149 switch (parameterType) {
2150 case SDDS_INT16:
2151 int16Value = (int16_t*)SDDS_realloc(int16Value, sizeof(int16_t) * page);
2152 if (SDDS_bufferedRead(&(int16Value[p]), 2, gzfp, fBuffer, sddsfile)) {
2153 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2154 return(1);
2155 }
2156 break;
2157 case SDDS_UINT16:
2158 uint16Value = (uint16_t*)SDDS_realloc(uint16Value, sizeof(uint16_t) * page);
2159 if (SDDS_bufferedRead(&(uint16Value[p]), 2, gzfp, fBuffer, sddsfile)) {
2160 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2161 return(1);
2162 }
2163 break;
2164 case SDDS_INT32:
2165 int32Value = (int32_t*)SDDS_realloc(int32Value, sizeof(int32_t) * page);
2166 if (SDDS_bufferedRead(&(int32Value[p]), 4, gzfp, fBuffer, sddsfile)) {
2167 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2168 return(1);
2169 }
2170 break;
2171 case SDDS_UINT32:
2172 uint32Value = (uint32_t*)SDDS_realloc(uint32Value, sizeof(uint32_t) * page);
2173 if (SDDS_bufferedRead(&(uint32Value[p]), 4, gzfp, fBuffer, sddsfile)) {
2174 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2175 return(1);
2176 }
2177 break;
2178 case SDDS_REAL32:
2179 real32Value = (float*)SDDS_realloc(real32Value, sizeof(float) * page);
2180 if (SDDS_bufferedRead(&(real32Value[p]), 4, gzfp, fBuffer, sddsfile)) {
2181 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2182 return(1);
2183 }
2184 break;
2185 case SDDS_REAL64:
2186 real64Value = (double*)SDDS_realloc(real64Value, sizeof(double) * page);
2187 if (SDDS_bufferedRead(&(real64Value[p]), 8, gzfp, fBuffer, sddsfile)) {
2188 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2189 return(1);
2190 }
2191 break;
2192 case SDDS_STRING:
2193 stringValue = (char**)SDDS_realloc(stringValue, sizeof(char*) * page);
2194 stringValue[p] = NULL;
2195 if (SDDS_readBinaryString(&(stringValue[p]), gzfp, fBuffer, sddsfile)) {
2196 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading string (SDDSParameter::readBinaryValue)");
2197 return(1);
2198 }
2199 break;
2200 case SDDS_CHARACTER:
2201 charValue = (char*)SDDS_realloc(charValue, sizeof(char) * page);
2202 if (SDDS_bufferedRead(&(charValue[p]), 1, gzfp, fBuffer, sddsfile)) {
2203 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--failure reading value (SDDSParameter::readBinaryValue)");
2204 return(1);
2205 }
2206 break;
2207 default:
2208 ((SDDSFile*)sddsfile)->setError((char*)"Unable to read parameter--unknown type (SDDSParameter::readBinaryValue)");
2209 return(1);
2210 }
2211 pageCount = page;
2212 return(0);
2213}
SDDS_NUM_TYPES
#define SDDS_NUM_TYPES
Total number of defined SDDS data types.
Definition SDDStypes.h:97
SDDS_INTEGER_TYPE
#define SDDS_INTEGER_TYPE(type)
Checks if the given type identifier corresponds to an integer type.
Definition SDDStypes.h:109
SDDS_STRING
#define SDDS_STRING
Identifier for the string data type.
Definition SDDStypes.h:85
SDDS_FLOATING_TYPE
#define SDDS_FLOATING_TYPE(type)
Checks if the given type identifier corresponds to a floating-point type.
Definition SDDStypes.h:124
SDDS_CHARACTER
#define SDDS_CHARACTER
Identifier for the character data type.
Definition SDDStypes.h:91
SDDS_FILEBUFFER
Definition SDDS.h:300
Generated by doxygen 1.12.0