IODA
02-Attributes.c
Go to the documentation of this file.
1 /*
2  * (C) Copyright 2020-2021 UCAR
3  *
4  * This software is licensed under the terms of the Apache Licence Version 2.0
5  * which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
6  */
7 /*! \addtogroup ioda_c_ex
8  *
9  * @{
10  *
11  * \defgroup ioda_c_ex_2 Ex 2: Attribute manipulation
12  * \brief Attribute manipulation using the C interface
13  * \details This example parallels the C++ examples.
14  * \see 02-Attributes.cpp for comments and the walkthrough.
15  *
16  * @{
17  *
18  * \file 02-Attributes.c
19  * \brief Attribute manipulation using the C interface
20  * \see 02-Attributes.cpp for comments and the walkthrough.
21  **/
22 
23 #include <stdio.h>
24 #include <string.h>
25 
26 #include "ioda/C/ioda_c.h"
27 #include "ioda/defs.h" // Always include this first.
28 
29 #define sslin(x) #x
30 #define slin(x) sslin(x)
31 #define doErr \
32  { \
33  errlin = "Error in " __FILE__ " at line " slin(__LINE__) ".\n"; \
34  goto hadError; \
35  }
36 
37 int main(int argc, char** argv) {
38  int errval = 0;
39  const char* errlin = NULL;
40  struct c_ioda ioda = use_c_ioda();
41  struct ioda_group* g = NULL;
42  struct ioda_has_attributes* gatts = NULL;
43  struct ioda_attribute *intatt1 = NULL, *intatt2 = NULL, *intatt3 = NULL, *intatt4 = NULL;
44  struct ioda_attribute *intatt5 = NULL, *intatt6 = NULL, *intatt7 = NULL, *intatt8 = NULL;
45  struct ioda_attribute *floatatt1 = NULL, *doubleatt1 = NULL, *stratt1 = NULL, *charatt1 = NULL;
46  struct ioda_attribute *f1 = NULL, *d1 = NULL;
47  struct ioda_dimensions* f1_dims = NULL;
48  struct ioda_string_ret_t *att_list = NULL, *str_list = NULL;
49 
50  g = ioda.Engines.constructFromCmdLine(argc, argv, "Example-02-C.hdf5");
51  if (!g) doErr;
52 
53  gatts = ioda.Group.getAtts(g);
54  if (!gatts) doErr;
55 
56  long intatt1_dims[1] = {1};
57  intatt1 = ioda.Group.atts.create_int(gatts, 9, "int-att-1", 1, intatt1_dims);
58  if (!intatt1) doErr;
59  int intatt1_data[1] = {5};
60  if (!ioda.Attribute.write_int(intatt1, 1, intatt1_data)) doErr;
61 
62  long intatt2_dims[1] = {2};
63  intatt2 = ioda.Group.atts.create_int(gatts, 9, "int-att-2", 1, intatt2_dims);
64  if (!intatt2) doErr;
65  int intatt2_data[] = {1, 2};
66  if (!ioda.Attribute.write_int(intatt2, 2, intatt2_data)) doErr;
67 
68  long intatt3_dims[1] = {3};
69  intatt3 = ioda.Group.atts.create_int(gatts, 9, "int-att-3", 1, intatt3_dims);
70  if (!intatt3) doErr;
71  int intatt3_data[] = {1, 2, 3};
72  if (!ioda.Attribute.write_int(intatt3, 3, intatt3_data)) doErr;
73 
74  long intatt4_dims[1] = {1};
75  intatt4 = ioda.Group.atts.create_int(gatts, 9, "int-att-4", 1, intatt4_dims);
76  if (!intatt4) doErr;
77  int intatt4_data[] = {42};
78  if (!ioda.Attribute.write_int(intatt4, 1, intatt4_data)) doErr;
79 
80  long intatt5_dims[] = {9};
81  intatt5 = ioda.Group.atts.create_int(gatts, 9, "int-att-5", 1, intatt5_dims);
82  if (!intatt5) doErr;
83  int intatt5_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
84  if (!ioda.Attribute.write_int(intatt5, 9, intatt5_data)) doErr;
85 
86  long intatt6_dims[] = {6};
87  intatt6 = ioda.Group.atts.create_int(gatts, 9, "int-att-6", 1, intatt6_dims);
88  if (!intatt6) doErr;
89  int intatt6_data[] = {1, 2, 3, 4, 5, 6};
90  if (!ioda.Attribute.write_int(intatt6, 6, intatt6_data)) doErr;
91 
92  long intatt7_dims[] = {4};
93  intatt7 = ioda.Group.atts.create_int(gatts, 9, "int-att-7", 1, intatt7_dims);
94  if (!intatt7) doErr;
95  int intatt7_data[] = {1, 2, 3, 4};
96  if (!ioda.Attribute.write_int(intatt7, 4, intatt7_data)) doErr;
97 
98  long intatt8_dims[] = {7};
99  intatt8 = ioda.Group.atts.create_int(gatts, 9, "int-att-8", 1, intatt8_dims);
100  if (!intatt8) doErr;
101  int intatt8_data[] = {1, 2, 3, 4, 5, 6, 7};
102  if (!ioda.Attribute.write_int(intatt8, 7, intatt8_data)) doErr;
103 
104  long float1_dims[] = {2};
105  floatatt1 = ioda.Group.atts.create_float(gatts, 7, "float-1", 1, float1_dims);
106  if (!floatatt1) doErr;
107  float float1_data[] = {3.1159f, 2.78f};
108  if (!ioda.Attribute.write_float(floatatt1, 2, float1_data)) doErr;
109 
110  long double1_dims[] = {4};
111  doubleatt1 = ioda.Group.atts.create_double(gatts, 8, "double-1", 1, double1_dims);
112  if (!doubleatt1) doErr;
113  double double1_data[] = {1.1, 2.2, 3.3, 4.4};
114  if (!ioda.Attribute.write_double(doubleatt1, 4, double1_data)) doErr;
115 
116  long str1_dims[] = {1};
117  stratt1 = ioda.Group.atts.create_str(gatts, 5, "str-1", 1, str1_dims);
118  if (!stratt1) doErr;
119  const char* str1_data1 = "This is a test.";
120  const char* str1_data[] = {str1_data1};
121  if (!ioda.Attribute.write_str(stratt1, 1, str1_data)) doErr;
122 
123  const char char1_data[15] = "This is a test"; // Note: an array, not a pointer.
124  long char1_dims[1] = {15}; // Note: sizeof(array) vs sizeof(pointer)
125  charatt1 = ioda.Group.atts.create_char(gatts, 6, "char-1", 1, char1_dims);
126  if (!charatt1) doErr;
127  if (!ioda.Attribute.write_char(charatt1, 15, char1_data)) doErr;
128 
129  str_list = ioda.Attribute.read_str(stratt1);
130  if (!str_list) doErr;
131  if (str_list->n != 1) doErr;
132 
133  att_list = ioda.Group.atts.list(gatts);
134  if (!att_list) doErr;
135  if (att_list->n != 12) doErr;
136  // att_list->strings[0 - 11] are the strings!
137 
138  f1 = ioda.Group.atts.open(gatts, 7, "float-1");
139  if (!f1) doErr;
140  d1 = ioda.Group.atts.open(gatts, 8, "double-1");
141  if (!d1) doErr;
142 
143  f1_dims = ioda.Attribute.getDimensions(f1);
144  if (!f1_dims) doErr;
145  size_t f1_dimensionality = 0;
146  if (!ioda.Dimensions.getDimensionality(f1_dims, &f1_dimensionality)) doErr;
147  if (f1_dimensionality != 1) doErr;
148  ptrdiff_t dim = 0;
149  if (!ioda.Dimensions.getDimCur(f1_dims, 0, &dim)) doErr;
150  if (dim != 2) doErr;
151  if (!ioda.Dimensions.getDimMax(f1_dims, 0, &dim)) doErr;
152  if (dim != 2) doErr;
153  size_t f1_numelems = 0;
154  if (!ioda.Dimensions.getNumElements(f1_dims, &f1_numelems)) doErr;
155  if (f1_numelems != 2) doErr;
156 
157  // Updating the struct does not update the attribute's dimensions.
158  if (!ioda.Dimensions.setDimensionality(f1_dims, 3)) doErr;
159  if (!ioda.Dimensions.setDimCur(f1_dims, 1, 5)) doErr;
160  if (!ioda.Dimensions.setDimCur(f1_dims, 2, 7)) doErr;
161  if (!ioda.Dimensions.setDimMax(f1_dims, 1, 5)) doErr;
162  if (!ioda.Dimensions.setDimMax(f1_dims, 2, 7)) doErr;
163 
164  if (ioda.Attribute.isA_int(intatt1) <= 0) doErr;
165 
166  int check_intatt1_val = 0;
167  if (!ioda.Attribute.read_int(intatt1, 1, &check_intatt1_val)) doErr;
168  if (check_intatt1_val != 5) doErr;
169 
170  float check_floatatt1_val[2];
171  if (!ioda.Attribute.read_float(floatatt1, 2, check_floatatt1_val)) doErr;
172 
173  double check_doubleatt1_val[4];
174  if (!ioda.Attribute.read_double(doubleatt1, 4, check_doubleatt1_val)) doErr;
175 
176  if (ioda.Has_Attributes.exists(gatts, 9, "int-att-1") <= 0) doErr;
177 
178  if (!ioda.Has_Attributes.rename_att(gatts, 9, "int-att-2", 10, "int-add-2b")) doErr;
179 
180  ioda.Attribute.destruct(intatt3);
181  intatt3 = NULL;
182 
183  if (!ioda.Has_Attributes.remove(gatts, 9, "int-att-3")) doErr;
184 
185  goto cleanup;
186 
187 hadError:
188  printf("%s", (errlin) ? errlin : "An unknown error has occurred somewhere.");
189  errval = 1;
190 cleanup:
191  if (g) ioda.Group.destruct(g);
192  if (gatts) ioda.Has_Attributes.destruct(gatts);
193  if (intatt1) ioda.Attribute.destruct(intatt1);
194  if (intatt2) ioda.Attribute.destruct(intatt2);
195  if (intatt3) ioda.Attribute.destruct(intatt3);
196  if (intatt4) ioda.Attribute.destruct(intatt4);
197  if (intatt5) ioda.Attribute.destruct(intatt5);
198  if (intatt6) ioda.Attribute.destruct(intatt6);
199  if (intatt7) ioda.Attribute.destruct(intatt7);
200  if (intatt8) ioda.Attribute.destruct(intatt8);
201  if (floatatt1) ioda.Attribute.destruct(floatatt1);
202  if (doubleatt1) ioda.Attribute.destruct(doubleatt1);
203  if (stratt1) ioda.Attribute.destruct(stratt1);
204  if (charatt1) ioda.Attribute.destruct(charatt1);
205  if (f1) ioda.Attribute.destruct(f1);
206  if (d1) ioda.Attribute.destruct(d1);
207  if (f1_dims) ioda.Dimensions.destruct(f1_dims);
208  if (att_list) ioda.Strings.destruct(att_list);
209  if (str_list) ioda.Strings.destruct(str_list);
210 
211  return errval;
212 }
ioda::Attribute
This class represents attributes, which may be attached to both Variables and Groups.
Definition: Attribute.h:493
ioda::Group
Groups are a new implementation of ObsSpaces.
Definition: Group.h:159
ioda::Has_Attributes
This class exists inside of ioda::Group or ioda::Variable and provides the interface to manipulating ...
Definition: Has_Attributes.h:390
ioda::detail::Attribute_Base::getDimensions
virtual Dimensions getDimensions() const
Get Attribute's dimensions.
Definition: Attribute.cpp:35
ioda::detail::Group_Base::atts
Has_Attributes atts
Use this to access the metadata for the group / ObsSpace.
Definition: Group.h:120
ioda::detail::Has_Attributes_Base::list
virtual std::vector< std::string > list() const
Definition: Has_Attributes.cpp:18
ioda::detail::Has_Attributes_Base::remove
virtual void remove(const std::string &attname)
Delete an Attribute with the specified name.
Definition: Has_Attributes.cpp:42
ioda::detail::Has_Attributes_Base::open
virtual Attribute open(const std::string &name) const
Open an Attribute by name.
Definition: Has_Attributes.cpp:54
ioda::detail::Has_Attributes_Base::exists
virtual bool exists(const std::string &attname) const
Does an Attribute with the specified name exist?
Definition: Has_Attributes.cpp:30
defs.h
Common preprocessor definitions used throughout IODA.
use_c_ioda
IODA_DL struct c_ioda use_c_ioda()
Creates and returns a c_ioda struct that has all of the function pointers filled in.
Definition: ioda_c.cpp:18
main
int main(int argc, char **argv)
Definition: 02-Attributes.c:37
doErr
#define doErr
Definition: 02-Attributes.c:31
ioda_c.h
C bindings for ioda-engines.
02-Attributes.f1
f1
Definition: 02-Attributes.py:119
02-Attributes.g
g
Definition: 02-Attributes.py:56
02-Attributes.d1
d1
Definition: 02-Attributes.py:120
02-Attributes.intatt3
intatt3
Definition: 02-Attributes.py:96
02-Attributes.intatt2
intatt2
Definition: 02-Attributes.py:89
02-Attributes.intatt1
intatt1
Definition: 02-Attributes.py:71
02-Attributes.f1_dims
f1_dims
Definition: 02-Attributes.py:132
ioda::Engines
The backends that implement the ioda-engines functionality.
Definition: Capabilities.h:21
c_ioda
Definition: ioda_c.h:35
ioda::Dimensions
Describes the dimensions of an Attribute or Variable.
Definition: Dimensions.h:22
ioda_attribute
Definition: structs_c.h:29
ioda_dimensions
Definition: structs_c.h:35
ioda_group
Definition: structs_c.h:20
ioda_has_attributes
Definition: structs_c.h:23
ioda_string_ret_t
Return type when arrays of strings are encountered.
Definition: String_c.h:24
ioda_string_ret_t::n
size_t n
Definition: String_c.h:25