NetCDF-C++ 4.3.2
Loading...
Searching...
No Matches
ncVar.cpp
1#include "ncVarAtt.h"
2#include "ncDim.h"
3#include "ncVar.h"
4#include "ncGroup.h"
5#include "ncCheck.h"
6#include "ncException.h"
7#include <cstddef>
8#include<netcdf.h>
9using namespace std;
10using namespace netCDF::exceptions;
11
12namespace netCDF {
13 // Global comparator operator ==============
14 // comparator operator
15 bool operator<(const NcVar& lhs,const NcVar& rhs)
16 {
17 return false;
18 }
19
20 // comparator operator
21 bool operator>(const NcVar& lhs,const NcVar& rhs)
22 {
23 return true;
24 }
25}
26
27using namespace netCDF;
28
29// assignment operator
31{
32 nullObject = rhs.nullObject;
33 myId = rhs.myId;
34 groupId = rhs.groupId;
35 return *this;
36}
37
38// The copy constructor.
39NcVar::NcVar(const NcVar& rhs) :
40 nullObject(rhs.nullObject),
41 myId(rhs.myId),
42 groupId(rhs.groupId)
43{}
44
45
46// equivalence operator
47bool NcVar::operator==(const NcVar & rhs) const
48{
49 // simply check the netCDF id.
50 return (myId == rhs.myId);
51}
52
53// != operator
54bool NcVar::operator!=(const NcVar & rhs) const
55{
56 return !(*this == rhs);
57}
58
60
61// Constructors and intialization
62
64
65// Constructor generates a null object.
66NcVar::NcVar() : nullObject(true),
67 myId(-1),
68 groupId(-1)
69{}
70
71// Constructor for a variable (must already exist in the netCDF file.)
72NcVar::NcVar (const NcGroup& grp, const int& varId) :
73 nullObject (false),
74 myId (varId),
75 groupId(grp.getId())
76{}
77
78
79
80// Gets parent group.
82 return NcGroup(groupId);
83}
84
85
86// Get the variable id.
87int NcVar::getId() const {return myId;}
88
90
91// Information about the variable type
92
94
95
96// Gets the NcType object with a given name.
98
99 // if this variable has not been defined, return a NULL type
100 if(isNull()) return NcType();
101
102 // first get the typeid
103 nc_type xtypep;
104 ncCheck(nc_inq_vartype(groupId,myId,&xtypep),__FILE__,__LINE__);
105
106 if(xtypep == ncByte.getId() ) return ncByte;
107 if(xtypep == ncUbyte.getId() ) return ncUbyte;
108 if(xtypep == ncChar.getId() ) return ncChar;
109 if(xtypep == ncShort.getId() ) return ncShort;
110 if(xtypep == ncUshort.getId() ) return ncUshort;
111 if(xtypep == ncInt.getId() ) return ncInt;
112 if(xtypep == ncUint.getId() ) return ncUint;
113 if(xtypep == ncInt64.getId() ) return ncInt64;
114 if(xtypep == ncUint64.getId() ) return ncUint64;
115 if(xtypep == ncFloat.getId() ) return ncFloat;
116 if(xtypep == ncDouble.getId() ) return ncDouble;
117 if(xtypep == ncString.getId() ) return ncString;
118
119 multimap<string,NcType>::const_iterator it;
120 multimap<string,NcType> types(NcGroup(groupId).getTypes(NcGroup::ParentsAndCurrent));
121 for(it=types.begin(); it!=types.end(); it++) {
122 if(it->second.getId() == xtypep) return it->second;
123 }
124 // we will never reach here
125 return true;
126}
127
128
129
130
131
132
133
134
136
137// Information about Dimensions
138
140
141
142// Gets the number of dimensions.
144{
145 // get the number of dimensions
146 int dimCount;
147 ncCheck(nc_inq_varndims(groupId,myId, &dimCount),__FILE__,__LINE__);
148 return dimCount;
149}
150
151// Gets the set of Ncdim objects.
152vector<NcDim> NcVar::getDims() const
153{
154 // get the number of dimensions
155 const auto dimCount = static_cast<std::size_t>(getDimCount());
156 // create a vector of dimensions.
157 vector<NcDim> ncDims;
158 if (dimCount){
159 vector<int> dimids(dimCount);
160 ncCheck(nc_inq_vardimid(groupId,myId, &dimids[0]),__FILE__,__LINE__);
161 ncDims.reserve(dimCount);
162 for (auto dimid : dimids) {
163 NcDim tmpDim(getParentGroup(), dimid);
164 ncDims.push_back(tmpDim);
165 }
166 }
167 return ncDims;
168}
169
170
171// Gets the i'th NcDim object.
173{
174 vector<NcDim> ncDims = getDims();
175 if((size_t)i >= ncDims.size() || i < 0) throw NcException("Index out of range",__FILE__,__LINE__);
176 return ncDims[static_cast<std::size_t>(i)];
177}
178
179
181
182// Information about Attributes
183
185
186
187// Gets the number of attributes.
189{
190 // get the number of attributes
191 int attCount;
192 ncCheck(nc_inq_varnatts(groupId,myId, &attCount),__FILE__,__LINE__);
193 return attCount;
194}
195
196// Gets the set of attributes.
197map<string,NcVarAtt> NcVar::getAtts() const
198{
199 // get the number of attributes
200 int attCount = getAttCount();
201 // create a container of attributes.
202 map<string,NcVarAtt> ncAtts;
203 for (int i=0; i<attCount; i++){
204 NcVarAtt tmpAtt(getParentGroup(),*this,i);
205 ncAtts.emplace(tmpAtt.getName(), tmpAtt);
206 }
207 return ncAtts;
208}
209
210
211// Gets attribute by name.
212NcVarAtt NcVar::getAtt(const string& name) const
213{
214 map<string,NcVarAtt> attributeList = getAtts();
215 map<string,NcVarAtt>::iterator myIter;
216 myIter = attributeList.find(name);
217 if(myIter == attributeList.end()){
218 string msg("Attribute '"+name+"' not found");
219 throw NcException(msg.c_str(),__FILE__,__LINE__);
220 }
221 return NcVarAtt(myIter->second);
222}
223
224
225
227
228// Creates a new NetCDF variable attribute or if already exisiting replaces it.
229NcVarAtt NcVar::putAtt(const string& name, const string& dataValues) const {
230 ncCheckDefineMode(groupId);
231 ncCheck(nc_put_att_text(groupId,myId,name.c_str(),dataValues.size(),dataValues.c_str()),__FILE__,__LINE__);
232 // finally instantiate this attribute and return
233 return getAtt(name);
234}
235
236// Creates a new NetCDF variable attribute or if already exisiting replaces it.
237NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const unsigned char* dataValues) const {
238 ncCheckDefineMode(groupId);
239 if (type.isNonPrimitive()) {
240 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
241 } else {
242 ncCheck(nc_put_att_uchar(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
243 }
244 // finally instantiate this attribute and return
245 return getAtt(name);
246}
247
248
249// Creates a new NetCDF variable attribute or if already exisiting replaces it.
250NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const signed char* dataValues) const {
251 ncCheckDefineMode(groupId);
252 if (type.isNonPrimitive()) {
253 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
254 } else {
255 ncCheck(nc_put_att_schar(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
256 }
257 // finally instantiate this attribute and return
258 return getAtt(name);
259}
260
261
262
264// Creates a new NetCDF variable attribute or if already exisiting replaces it.
265NcVarAtt NcVar::putAtt(const string& name, const NcType& type, short datumValue) const {
266 ncCheckDefineMode(groupId);
267 if (type.isNonPrimitive()) {
268 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
269 } else {
270 ncCheck(nc_put_att_short(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
271 }
272 // finally instantiate this attribute and return
273 return getAtt(name);
274}
275
276
277// Creates a new NetCDF variable attribute or if already exisiting replaces it.
278NcVarAtt NcVar::putAtt(const string& name, const NcType& type, int datumValue) const {
279 ncCheckDefineMode(groupId);
280 if (type.isNonPrimitive()) {
281 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
282 } else {
283 ncCheck(nc_put_att_int(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
284 }
285 // finally instantiate this attribute and return
286 return getAtt(name);
287}
288
289// Creates a new NetCDF variable attribute or if already exisiting replaces it.
290NcVarAtt NcVar::putAtt(const string& name, const NcType& type, long datumValue) const {
291 ncCheckDefineMode(groupId);
292 if (type.isNonPrimitive()) {
293 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
294 } else {
295 ncCheck(nc_put_att_long(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
296 }
297 // finally instantiate this attribute and return
298 return getAtt(name);
299}
300
301// Creates a new NetCDF variable attribute or if already exisiting replaces it.
302NcVarAtt NcVar::putAtt(const string& name, const NcType& type, float datumValue) const {
303 ncCheckDefineMode(groupId);
304 if (type.isNonPrimitive()) {
305 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
306 } else {
307 ncCheck(nc_put_att_float(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
308 }
309 // finally instantiate this attribute and return
310 return getAtt(name);
311}
312
313
314// Creates a new NetCDF variable attribute or if already exisiting replaces it.
315NcVarAtt NcVar::putAtt(const string& name, const NcType& type, double datumValue) const {
316 ncCheckDefineMode(groupId);
317 if (type.isNonPrimitive()) {
318 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
319 } else {
320 ncCheck(nc_put_att_double(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
321 }
322 // finally instantiate this attribute and return
323 return getAtt(name);
324}
325
326
327// Creates a new NetCDF variable attribute or if already exisiting replaces it.
328NcVarAtt NcVar::putAtt(const string& name, const NcType& type, unsigned short datumValue) const {
329 ncCheckDefineMode(groupId);
330 if (type.isNonPrimitive()) {
331 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
332 } else {
333 ncCheck(nc_put_att_ushort(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
334 }
335 // finally instantiate this attribute and return
336 return getAtt(name);
337}
338
339// Creates a new NetCDF variable attribute or if already exisiting replaces it.
340NcVarAtt NcVar::putAtt(const string& name, const NcType& type, unsigned int datumValue) const {
341 ncCheckDefineMode(groupId);
342 if (type.isNonPrimitive()) {
343 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
344 } else {
345 ncCheck(nc_put_att_uint(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
346 }
347 // finally instantiate this attribute and return
348 return getAtt(name);
349}
350
351// Creates a new NetCDF variable attribute or if already exisiting replaces it.
352NcVarAtt NcVar::putAtt(const string& name, const NcType& type, long long datumValue) const {
353 ncCheckDefineMode(groupId);
354 if (type.isNonPrimitive()) {
355 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
356 } else {
357 ncCheck(nc_put_att_longlong(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
358 }
359 // finally instantiate this attribute and return
360 return getAtt(name);
361}
362
363
364// Creates a new NetCDF variable attribute or if already exisiting replaces it.
365NcVarAtt NcVar::putAtt(const string& name, const NcType& type, unsigned long long datumValue) const {
366 ncCheckDefineMode(groupId);
367 if (type.isNonPrimitive()) {
368 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
369 } else {
370 ncCheck(nc_put_att_ulonglong(groupId,myId,name.c_str(),type.getId(),1,&datumValue),__FILE__,__LINE__);
371 }
372 // finally instantiate this attribute and return
373 return getAtt(name);
374}
375
376
378
379
380
381
382
383
384
385
386
387
388
389// Creates a new NetCDF variable attribute or if already exisiting replaces it.
390NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const short* dataValues) const {
391 ncCheckDefineMode(groupId);
392 if (type.isNonPrimitive()) {
393 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
394 } else {
395 ncCheck(nc_put_att_short(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
396 }
397 // finally instantiate this attribute and return
398 return getAtt(name);
399}
400
401
402// Creates a new NetCDF variable attribute or if already exisiting replaces it.
403NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const int* dataValues) const {
404 ncCheckDefineMode(groupId);
405 if (type.isNonPrimitive()) {
406 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
407 } else {
408 ncCheck(nc_put_att_int(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
409 }
410 // finally instantiate this attribute and return
411 return getAtt(name);
412}
413
414// Creates a new NetCDF variable attribute or if already exisiting replaces it.
415NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const long* dataValues) const {
416 ncCheckDefineMode(groupId);
417 if (type.isNonPrimitive()) {
418 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
419 } else {
420 ncCheck(nc_put_att_long(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
421 }
422 // finally instantiate this attribute and return
423 return getAtt(name);
424}
425
426// Creates a new NetCDF variable attribute or if already exisiting replaces it.
427NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const float* dataValues) const {
428 ncCheckDefineMode(groupId);
429 if (type.isNonPrimitive()) {
430 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
431 } else {
432 ncCheck(nc_put_att_float(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
433 }
434 // finally instantiate this attribute and return
435 return getAtt(name);
436}
437
438
439// Creates a new NetCDF variable attribute or if already exisiting replaces it.
440NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const double* dataValues) const {
441 ncCheckDefineMode(groupId);
442 if (type.isNonPrimitive()) {
443 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
444 } else {
445 ncCheck(nc_put_att_double(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
446 }
447 // finally instantiate this attribute and return
448 return getAtt(name);
449}
450
451
452// Creates a new NetCDF variable attribute or if already exisiting replaces it.
453NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const unsigned short* dataValues) const {
454 ncCheckDefineMode(groupId);
455 if (type.isNonPrimitive()) {
456 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
457 } else {
458 ncCheck(nc_put_att_ushort(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
459 }
460 // finally instantiate this attribute and return
461 return getAtt(name);
462}
463
464// Creates a new NetCDF variable attribute or if already exisiting replaces it.
465NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const unsigned int* dataValues) const {
466 ncCheckDefineMode(groupId);
467 if (type.isNonPrimitive()) {
468 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
469 } else {
470 ncCheck(nc_put_att_uint(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
471 }
472 // finally instantiate this attribute and return
473 return getAtt(name);
474}
475
476// Creates a new NetCDF variable attribute or if already exisiting replaces it.
477NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const long long* dataValues) const {
478 ncCheckDefineMode(groupId);
479 if (type.isNonPrimitive()) {
480 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
481 } else {
482 ncCheck(nc_put_att_longlong(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
483 }
484 // finally instantiate this attribute and return
485 return getAtt(name);
486}
487
488
489// Creates a new NetCDF variable attribute or if already exisiting replaces it.
490NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const unsigned long long* dataValues) const {
491 ncCheckDefineMode(groupId);
492 if (type.isNonPrimitive()) {
493 ncCheck(nc_put_att(groupId,myId,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
494 } else {
495 ncCheck(nc_put_att_ulonglong(groupId,myId,name.c_str(),type.getId(),len,dataValues), __FILE__, __LINE__);
496 }
497 // finally instantiate this attribute and return
498 return getAtt(name);
499}
500
501
502// Creates a new NetCDF variable attribute or if already exisiting replaces it.
503NcVarAtt NcVar::putAtt(const string& name, size_t len, const char** dataValues) const {
504 ncCheckDefineMode(groupId);
505 ncCheck(nc_put_att_string(groupId,myId,name.c_str(),len,dataValues),__FILE__,__LINE__);
506 // finally instantiate this attribute and return
507 return getAtt(name);
508}
509
510// Creates a new NetCDF variable attribute or if already exisiting replaces it.
511NcVarAtt NcVar::putAtt(const string& name, const NcType& type, size_t len, const void* dataValues) const {
512 ncCheckDefineMode(groupId);
513 ncCheck(nc_put_att(groupId,myId ,name.c_str(),type.getId(),len,dataValues),__FILE__,__LINE__);
514 // finally instantiate this attribute and return
515 return getAtt(name);
516}
517
518
519
520
522
523// Other Basic variable info
524
526
527// The name of this variable.
528string NcVar::getName() const{
529 char charName[NC_MAX_NAME+1];
530 ncCheck(nc_inq_varname(groupId, myId, charName),__FILE__,__LINE__);
531 return string(charName);
532}
533
534
536
537// Chunking details
538
540
541
542// Sets chunking parameters.
543void NcVar::setChunking(ChunkMode chunkMode, vector<size_t>& chunkSizes) const {
544 size_t *chunkSizesPtr = chunkSizes.empty() ? 0 : &chunkSizes[0];
545 ncCheck(nc_def_var_chunking(groupId,myId,static_cast<int> (chunkMode), chunkSizesPtr),__FILE__,__LINE__);
546}
547
548
549// Gets the chunking parameters
550void NcVar::getChunkingParameters(ChunkMode& chunkMode, vector<size_t>& chunkSizes) const {
551 int chunkModeInt;
552 chunkSizes.resize(static_cast<std::size_t>(getDimCount()));
553 size_t *chunkSizesPtr = chunkSizes.empty() ? 0 : &chunkSizes[0];
554 ncCheck(nc_inq_var_chunking(groupId,myId, &chunkModeInt, chunkSizesPtr),__FILE__,__LINE__);
555 chunkMode = static_cast<ChunkMode> (chunkModeInt);
556}
557
558
559
560
562
563// Fill details
564
566
567
568// Sets the fill parameters
569void NcVar::setFill(bool fillMode, void* fillValue) const {
570 // If fillMode is enabled, check that fillValue has a legal pointer.
571 if(fillMode && fillValue == NULL)
572 throw NcException("FillMode was set to zero but fillValue has invalid pointer",__FILE__,__LINE__);
573
574 ncCheck(nc_def_var_fill(groupId,myId,static_cast<int> (!fillMode),fillValue),__FILE__,__LINE__);
575}
576
577// Sets the fill parameters
578void NcVar::setFill(bool fillMode,const void* fillValue) const {
579 setFill(fillMode,const_cast<void*>(fillValue));
580}
581
582
583
584// Gets the fill parameters
585void NcVar::getFillModeParameters(bool& fillMode, void* fillValue)const{
586
587 int fillModeInt;
588 ncCheck(nc_inq_var_fill(groupId,myId,&fillModeInt,fillValue),__FILE__,__LINE__);
589 fillMode= static_cast<bool> (fillModeInt == 0);
590}
591
592
594
595// Compression details
596
598
599
600// Sets the compression parameters
601void NcVar::setCompression(bool enableShuffleFilter, bool enableDeflateFilter, int deflateLevel) const {
602
603 // Check that the deflate level is legal
604 if(enableDeflateFilter & (deflateLevel < 0 || deflateLevel >9))
605 throw NcException("The deflateLevel must be set between 0 and 9.",__FILE__,__LINE__);
606
607 ncCheck(nc_def_var_deflate(groupId,myId,
608 static_cast<int> (enableShuffleFilter),
609 static_cast<int> (enableDeflateFilter),
610 deflateLevel),__FILE__,__LINE__);
611}
612
613// Gets the compression parameters
614void NcVar::getCompressionParameters(bool& shuffleFilterEnabled, bool& deflateFilterEnabled, int& deflateLevel) const {
615
616 int enableShuffleFilterInt;
617 int enableDeflateFilterInt;
618 ncCheck(nc_inq_var_deflate(groupId,myId,
619 &enableShuffleFilterInt,
620 &enableDeflateFilterInt,
621 &deflateLevel),__FILE__,__LINE__);
622 shuffleFilterEnabled = static_cast<bool> (enableShuffleFilterInt);
623 deflateFilterEnabled = static_cast<bool> (enableDeflateFilterInt);
624}
625
626// Define a variable filter to be used for compression (decompression)
627void NcVar::setFilter( unsigned int id, size_t nparams,
628 const unsigned int* parms) const
629{
630 ncCheck(nc_def_var_filter(groupId,myId,id,nparams,parms),__FILE__,__LINE__);
631}
632
633// Query filter details (if any) associated with a variable
634void NcVar::getFilter( unsigned int* idp, size_t* nparamsp, unsigned int* params) const
635{
636 ncCheck(nc_inq_var_filter(groupId, myId, idp, nparamsp, params),__FILE__,__LINE__);
637}
638
639// Query the length of a given Type
640void NcVar::getTypeLen(nc_type type) const
641{
642 ncCheck(nctypelen(type),__FILE__,__LINE__);
643}
644
645// Free string space allocated by the library
646void NcVar::freeString(size_t len, char **data) const
647{
648 ncCheck(nc_free_string(len, data),__FILE__,__LINE__);
649}
650
651// Change the cache settings for a chunked variable
652void NcVar::setChunkCache(size_t size, size_t nelems, float preemption) const
653{
654 ncCheck(nc_set_var_chunk_cache(groupId, myId, size, nelems, preemption),__FILE__,__LINE__);
655}
656
658
659// Endianness details
660
662
663
664// Sets the endianness of the variable.
665void NcVar::setEndianness(EndianMode endianMode) const {
666
667 ncCheck(nc_def_var_endian(groupId,myId,static_cast<int> (endianMode)),__FILE__,__LINE__);
668}
669
670
671// Gets the endianness of the variable.
673
674 int endianInt;
675 ncCheck(nc_inq_var_endian(groupId,myId,&endianInt),__FILE__,__LINE__);
676 return static_cast<EndianMode> (endianInt);
677}
678
679
680
682
683// Checksum details
684
686
687
688// Sets the checksum parameters of a variable.
689void NcVar::setChecksum(ChecksumMode checksumMode) const {
690 ncCheck(nc_def_var_fletcher32(groupId,myId,static_cast<int> (checksumMode)),__FILE__,__LINE__);
691}
692
693
694// Gets the checksum parameters of the variable.
696 int checksumInt;
697 ncCheck(nc_inq_var_fletcher32(groupId,myId,&checksumInt),__FILE__,__LINE__);
698 return static_cast<ChecksumMode> (checksumInt);
699}
700
701
702
703
705
706// renaming the variable
707
709
710void NcVar::rename( const string& newname ) const
711{
712 ncCheck(nc_rename_var(groupId,myId,newname.c_str()),__FILE__,__LINE__);
713}
714
715
716
717
718
720
721// data writing
722
724
725// Writes the entire data into the netCDF variable.
726void NcVar::putVar(const char* dataValues) const {
727 ncCheckDataMode(groupId);
728 if (getType().isNonPrimitive())
729 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
730 else
731 ncCheck(nc_put_var_text(groupId, myId,dataValues),__FILE__,__LINE__);
732}
733// Writes the entire data into the netCDF variable.
734void NcVar::putVar(const unsigned char* dataValues) const {
735 ncCheckDataMode(groupId);
736 if (getType().isNonPrimitive())
737 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
738 else
739 ncCheck(nc_put_var_uchar(groupId, myId,dataValues),__FILE__,__LINE__);
740}
741// Writes the entire data into the netCDF variable.
742void NcVar::putVar(const signed char* dataValues) const {
743 ncCheckDataMode(groupId);
744 if (getType().isNonPrimitive())
745 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
746 else
747 ncCheck(nc_put_var_schar(groupId, myId,dataValues),__FILE__,__LINE__);
748}
749// Writes the entire data into the netCDF variable.
750void NcVar::putVar(const short* dataValues) const {
751 ncCheckDataMode(groupId);
752 if (getType().isNonPrimitive())
753 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
754 else
755 ncCheck(nc_put_var_short(groupId, myId,dataValues),__FILE__,__LINE__);
756}
757// Writes the entire data into the netCDF variable.
758void NcVar::putVar(const int* dataValues) const {
759 ncCheckDataMode(groupId);
760 if (getType().isNonPrimitive())
761 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
762 else
763 ncCheck(nc_put_var_int(groupId, myId,dataValues),__FILE__,__LINE__);
764}
765// Writes the entire data into the netCDF variable.
766void NcVar::putVar(const long* dataValues) const {
767 ncCheckDataMode(groupId);
768 if (getType().isNonPrimitive())
769 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
770 else
771 ncCheck(nc_put_var_long(groupId, myId,dataValues),__FILE__,__LINE__);
772}
773// Writes the entire data into the netCDF variable.
774void NcVar::putVar(const float* dataValues) const {
775 ncCheckDataMode(groupId);
776 if (getType().isNonPrimitive())
777 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
778 else
779 ncCheck(nc_put_var_float(groupId, myId,dataValues),__FILE__,__LINE__);
780}
781// Writes the entire data into the netCDF variable.
782void NcVar::putVar(const double* dataValues) const {
783 ncCheckDataMode(groupId);
784 if (getType().isNonPrimitive())
785 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
786 else
787 ncCheck(nc_put_var_double(groupId, myId,dataValues),__FILE__,__LINE__);
788}
789// Writes the entire data into the netCDF variable.
790void NcVar::putVar(const unsigned short* dataValues) const {
791 ncCheckDataMode(groupId);
792 if (getType().isNonPrimitive())
793 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
794 else
795 ncCheck(nc_put_var_ushort(groupId, myId,dataValues),__FILE__,__LINE__);
796}
797// Writes the entire data into the netCDF variable.
798void NcVar::putVar(const unsigned int* dataValues) const {
799 ncCheckDataMode(groupId);
800 if (getType().isNonPrimitive())
801 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
802 else
803 ncCheck(nc_put_var_uint(groupId, myId,dataValues),__FILE__,__LINE__);
804}
805// Writes the entire data into the netCDF variable.
806void NcVar::putVar(const long long* dataValues) const {
807 ncCheckDataMode(groupId);
808 if (getType().isNonPrimitive())
809 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
810 else
811 ncCheck(nc_put_var_longlong(groupId, myId,dataValues),__FILE__,__LINE__);
812}
813// Writes the entire data into the netCDF variable.
814void NcVar::putVar(const unsigned long long* dataValues) const {
815 ncCheckDataMode(groupId);
816 if (getType().isNonPrimitive())
817 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
818 else
819 ncCheck(nc_put_var_ulonglong(groupId, myId,dataValues),__FILE__,__LINE__);
820}
821// Writes the entire data into the netCDF variable.
822void NcVar::putVar(const char** dataValues) const {
823 ncCheckDataMode(groupId);
824 if (getType().isNonPrimitive())
825 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
826 else
827 ncCheck(nc_put_var_string(groupId, myId,dataValues),__FILE__,__LINE__);
828}
829// Writes the entire data into the netCDF variable with no data conversion.
830void NcVar::putVar(const void* dataValues) const {
831 ncCheckDataMode(groupId);
832 ncCheck(nc_put_var(groupId, myId,dataValues),__FILE__,__LINE__);
833}
834
835
837// Writes a single datum value into the netCDF variable.
838void NcVar::putVar(const vector<size_t>& index, const string& datumValue) const {
839 ncCheckDataMode(groupId);
840 if (getType().isNonPrimitive())
841 throw NcException("user-defined type must be of type void",__FILE__,__LINE__);
842 else
843 {
844 const char* tmpPtr = datumValue.c_str();
845 ncCheck(nc_put_var1_string(groupId, myId,&index[0],&tmpPtr),__FILE__,__LINE__);
846 }
847}
848// Writes a single datum value into the netCDF variable.
849void NcVar::putVar(const vector<size_t>& index, const unsigned char* datumValue) const {
850 ncCheckDataMode(groupId);
851 if (getType().isNonPrimitive())
852 throw NcException("user-defined type must be of type void",__FILE__,__LINE__);
853 else
854 ncCheck(nc_put_var1_uchar(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
855}
856// Writes a single datum value into the netCDF variable.
857void NcVar::putVar(const vector<size_t>& index, const signed char* datumValue) const {
858 ncCheckDataMode(groupId);
859 if (getType().isNonPrimitive())
860 throw NcException("user-defined type must be of type void",__FILE__,__LINE__);
861 else
862 ncCheck(nc_put_var1_schar(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
863}
864// Writes a single datum value into the netCDF variable.
865void NcVar::putVar(const vector<size_t>& index, const short datumValue) const {
866 ncCheckDataMode(groupId);
867 if (getType().isNonPrimitive())
868 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
869 else
870 ncCheck(nc_put_var1_short(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
871}
872// Writes a single datum value into the netCDF variable.
873void NcVar::putVar(const vector<size_t>& index, const int datumValue) const {
874 ncCheckDataMode(groupId);
875 if (getType().isNonPrimitive())
876 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
877 else
878 ncCheck(nc_put_var1_int(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
879}
880// Writes a single datum value into the netCDF variable.
881void NcVar::putVar(const vector<size_t>& index, const long datumValue) const {
882 ncCheckDataMode(groupId);
883 if (getType().isNonPrimitive())
884 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
885 else
886 ncCheck(nc_put_var1_long(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
887}
888// Writes a single datum value into the netCDF variable.
889void NcVar::putVar(const vector<size_t>& index, const float datumValue) const {
890 ncCheckDataMode(groupId);
891 if (getType().isNonPrimitive())
892 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
893 else
894 ncCheck(nc_put_var1_float(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
895}
896// Writes a single datum value into the netCDF variable.
897void NcVar::putVar(const vector<size_t>& index, const double datumValue) const {
898 ncCheckDataMode(groupId);
899 if (getType().isNonPrimitive())
900 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
901 else
902 ncCheck(nc_put_var1_double(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
903}
904// Writes a single datum value into the netCDF variable.
905void NcVar::putVar(const vector<size_t>& index, const unsigned short datumValue) const {
906 ncCheckDataMode(groupId);
907 if (getType().isNonPrimitive())
908 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
909 else
910 ncCheck(nc_put_var1_ushort(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
911}
912// Writes a single datum value into the netCDF variable.
913void NcVar::putVar(const vector<size_t>& index, const unsigned int datumValue) const {
914 ncCheckDataMode(groupId);
915 if (getType().isNonPrimitive())
916 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
917 else
918 ncCheck(nc_put_var1_uint(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
919}
920// Writes a single datum value into the netCDF variable.
921void NcVar::putVar(const vector<size_t>& index, const long long datumValue) const {
922 ncCheckDataMode(groupId);
923 if (getType().isNonPrimitive())
924 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
925 else
926 ncCheck(nc_put_var1_longlong(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
927}
928// Writes a single datum value into the netCDF variable.
929void NcVar::putVar(const vector<size_t>& index, const unsigned long long datumValue) const {
930 ncCheckDataMode(groupId);
931 if (getType().isNonPrimitive())
932 ncCheck(nc_put_var1(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
933 else
934 ncCheck(nc_put_var1_ulonglong(groupId, myId,&index[0],&datumValue),__FILE__,__LINE__);
935}
936// Writes a single datum value into the netCDF variable.
937void NcVar::putVar(const vector<size_t>& index, const char** datumValue) const {
938 ncCheckDataMode(groupId);
939 if (getType().isNonPrimitive())
940 throw NcException("user-defined type must be of type void",__FILE__,__LINE__);
941 else
942 ncCheck(nc_put_var1_string(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
943}
944// Writes a single datum value into the netCDF variable with no data conversion.
945void NcVar::putVar(const vector<size_t>& index, const void* datumValue) const {
946 ncCheckDataMode(groupId);
947 ncCheck(nc_put_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
948}
949
950
952
953// Writes an array of values into the netCDF variable.
954void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const char* dataValues) const {
955 ncCheckDataMode(groupId);
956 if (getType().isNonPrimitive())
957 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
958 else
959 ncCheck(nc_put_vara_text(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
960}
961// Writes an array of values into the netCDF variable.
962void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const unsigned char* dataValues) const {
963 ncCheckDataMode(groupId);
964 if (getType().isNonPrimitive())
965 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
966 else
967 ncCheck(nc_put_vara_uchar(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
968}
969// Writes an array of values into the netCDF variable.
970void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const signed char* dataValues) const {
971 ncCheckDataMode(groupId);
972 if (getType().isNonPrimitive())
973 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
974 else
975 ncCheck(nc_put_vara_schar(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
976}
977// Writes an array of values into the netCDF variable.
978void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const short* dataValues) const {
979 ncCheckDataMode(groupId);
980 if (getType().isNonPrimitive())
981 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
982 else
983 ncCheck(nc_put_vara_short(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
984}
985// Writes an array of values into the netCDF variable.
986void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const int* dataValues) const {
987 ncCheckDataMode(groupId);
988 if (getType().isNonPrimitive())
989 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
990 else
991 ncCheck(nc_put_vara_int(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
992}
993// Writes an array of values into the netCDF variable.
994void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const long* dataValues) const {
995 ncCheckDataMode(groupId);
996 if (getType().isNonPrimitive())
997 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
998 else
999 ncCheck(nc_put_vara_long(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1000}
1001// Writes an array of values into the netCDF variable.
1002void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const float* dataValues) const {
1003 ncCheckDataMode(groupId);
1004 if (getType().isNonPrimitive())
1005 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1006 else
1007 ncCheck(nc_put_vara_float(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1008}
1009// Writes an array of values into the netCDF variable.
1010void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const double* dataValues) const {
1011 ncCheckDataMode(groupId);
1012 if (getType().isNonPrimitive())
1013 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1014 else
1015 ncCheck(nc_put_vara_double(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1016}
1017// Writes an array of values into the netCDF variable.
1018void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const unsigned short* dataValues) const {
1019 ncCheckDataMode(groupId);
1020 if (getType().isNonPrimitive())
1021 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1022 else
1023 ncCheck(nc_put_vara_ushort(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1024}
1025// Writes an array of values into the netCDF variable.
1026void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const unsigned int* dataValues) const {
1027 ncCheckDataMode(groupId);
1028 if (getType().isNonPrimitive())
1029 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1030 else
1031 ncCheck(nc_put_vara_uint(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1032}
1033// Writes an array of values into the netCDF variable.
1034void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const long long* dataValues) const {
1035 ncCheckDataMode(groupId);
1036 if (getType().isNonPrimitive())
1037 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1038 else
1039 ncCheck(nc_put_vara_longlong(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1040}
1041// Writes an array of values into the netCDF variable.
1042void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const unsigned long long* dataValues) const {
1043 ncCheckDataMode(groupId);
1044 if (getType().isNonPrimitive())
1045 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1046 else
1047 ncCheck(nc_put_vara_ulonglong(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1048}
1049// Writes an array of values into the netCDF variable.
1050void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const char** dataValues) const {
1051 ncCheckDataMode(groupId);
1052 if (getType().isNonPrimitive())
1053 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1054 else
1055 ncCheck(nc_put_vara_string(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1056}
1057// Writes an array of values into the netCDF variable with no data conversion.
1058void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>& countp, const void* dataValues) const {
1059 ncCheckDataMode(groupId);
1060 ncCheck(nc_put_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1061}
1062
1063
1064
1066
1067// Writes a set of subsampled array values into the netCDF variable.
1068void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const char* dataValues) const {
1069 ncCheckDataMode(groupId);
1070 if (getType().isNonPrimitive())
1071 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1072 else
1073 ncCheck(nc_put_vars_text(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1074}
1075// Writes a set of subsampled array values into the netCDF variable.
1076void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const unsigned char* dataValues) const {
1077 ncCheckDataMode(groupId);
1078 if (getType().isNonPrimitive())
1079 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1080 else
1081 ncCheck(nc_put_vars_uchar(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1082}
1083// Writes a set of subsampled array values into the netCDF variable.
1084void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const signed char* dataValues) const {
1085 ncCheckDataMode(groupId);
1086 if (getType().isNonPrimitive())
1087 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1088 else
1089 ncCheck(nc_put_vars_schar(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1090}
1091// Writes a set of subsampled array values into the netCDF variable.
1092void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const short* dataValues) const {
1093 ncCheckDataMode(groupId);
1094 if (getType().isNonPrimitive())
1095 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1096 else
1097 ncCheck(nc_put_vars_short(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1098}
1099// Writes a set of subsampled array values into the netCDF variable.
1100void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const int* dataValues) const {
1101 ncCheckDataMode(groupId);
1102 if (getType().isNonPrimitive())
1103 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1104 else
1105 ncCheck(nc_put_vars_int(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1106}
1107// Writes a set of subsampled array values into the netCDF variable.
1108void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const long* dataValues) const {
1109 ncCheckDataMode(groupId);
1110 if (getType().isNonPrimitive())
1111 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1112 else
1113 ncCheck(nc_put_vars_long(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1114}
1115// Writes a set of subsampled array values into the netCDF variable.
1116void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const float* dataValues) const {
1117 ncCheckDataMode(groupId);
1118 if (getType().isNonPrimitive())
1119 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1120 else
1121 ncCheck(nc_put_vars_float(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1122}
1123// Writes a set of subsampled array values into the netCDF variable.
1124void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const double* dataValues) const {
1125 ncCheckDataMode(groupId);
1126 if (getType().isNonPrimitive())
1127 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1128 else
1129 ncCheck(nc_put_vars_double(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1130}
1131// Writes a set of subsampled array values into the netCDF variable.
1132void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const unsigned short* dataValues) const {
1133 ncCheckDataMode(groupId);
1134 if (getType().isNonPrimitive())
1135 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1136 else
1137 ncCheck(nc_put_vars_ushort(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1138}
1139// Writes a set of subsampled array values into the netCDF variable.
1140void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const unsigned int* dataValues) const {
1141 ncCheckDataMode(groupId);
1142 if (getType().isNonPrimitive())
1143 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1144 else
1145 ncCheck(nc_put_vars_uint(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1146}
1147// Writes a set of subsampled array values into the netCDF variable.
1148void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const long long* dataValues) const {
1149 ncCheckDataMode(groupId);
1150 if (getType().isNonPrimitive())
1151 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1152 else
1153 ncCheck(nc_put_vars_longlong(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1154}
1155// Writes a set of subsampled array values into the netCDF variable.
1156void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const unsigned long long* dataValues) const {
1157 ncCheckDataMode(groupId);
1158 if (getType().isNonPrimitive())
1159 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1160 else
1161 ncCheck(nc_put_vars_ulonglong(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1162}
1163// Writes a set of subsampled array values into the netCDF variable.
1164void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const char** dataValues) const {
1165 ncCheckDataMode(groupId);
1166 if (getType().isNonPrimitive())
1167 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1168 else
1169 ncCheck(nc_put_vars_string(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1170}
1171// Writes a set of subsampled array values into the netCDF variable with no data conversion.
1172void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const void* dataValues) const {
1173 ncCheckDataMode(groupId);
1174 ncCheck(nc_put_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1175}
1176
1177
1179// Writes a mapped array section of values into the netCDF variable.
1180void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const char* dataValues) const {
1181 ncCheckDataMode(groupId);
1182 if (getType().isNonPrimitive())
1183 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1184 else
1185 ncCheck(nc_put_varm_text(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1186}
1187// Writes a mapped array section of values into the netCDF variable.
1188void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const unsigned char* dataValues) const {
1189 ncCheckDataMode(groupId);
1190 if (getType().isNonPrimitive())
1191 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1192 else
1193 ncCheck(nc_put_varm_uchar(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1194}
1195// Writes a mapped array section of values into the netCDF variable.
1196void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const signed char* dataValues) const {
1197 ncCheckDataMode(groupId);
1198 if (getType().isNonPrimitive())
1199 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1200 else
1201 ncCheck(nc_put_varm_schar(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1202}
1203// Writes a mapped array section of values into the netCDF variable.
1204void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const short* dataValues) const {
1205 ncCheckDataMode(groupId);
1206 if (getType().isNonPrimitive())
1207 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1208 else
1209 ncCheck(nc_put_varm_short(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1210}
1211// Writes a mapped array section of values into the netCDF variable.
1212void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const int* dataValues) const {
1213 ncCheckDataMode(groupId);
1214 if (getType().isNonPrimitive())
1215 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1216 else
1217 ncCheck(nc_put_varm_int(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1218}
1219// Writes a mapped array section of values into the netCDF variable.
1220void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const long* dataValues) const {
1221 ncCheckDataMode(groupId);
1222 if (getType().isNonPrimitive())
1223 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1224 else
1225 ncCheck(nc_put_varm_long(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1226}
1227// Writes a mapped array section of values into the netCDF variable.
1228void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const float* dataValues) const {
1229 ncCheckDataMode(groupId);
1230 if (getType().isNonPrimitive())
1231 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1232 else
1233 ncCheck(nc_put_varm_float(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1234}
1235// Writes a mapped array section of values into the netCDF variable.
1236void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const double* dataValues) const {
1237 ncCheckDataMode(groupId);
1238 if (getType().isNonPrimitive())
1239 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1240 else
1241 ncCheck(nc_put_varm_double(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1242}
1243// Writes a mapped array section of values into the netCDF variable.
1244void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const unsigned short* dataValues) const {
1245 ncCheckDataMode(groupId);
1246 if (getType().isNonPrimitive())
1247 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1248 else
1249 ncCheck(nc_put_varm_ushort(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1250}
1251// Writes a mapped array section of values into the netCDF variable.
1252void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const unsigned int* dataValues) const {
1253 ncCheckDataMode(groupId);
1254 if (getType().isNonPrimitive())
1255 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1256 else
1257 ncCheck(nc_put_varm_uint(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1258}
1259// Writes a mapped array section of values into the netCDF variable.
1260void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const long long* dataValues) const {
1261 ncCheckDataMode(groupId);
1262 if (getType().isNonPrimitive())
1263 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1264 else
1265 ncCheck(nc_put_varm_longlong(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1266}
1267// Writes a mapped array section of values into the netCDF variable.
1268void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const unsigned long long* dataValues) const {
1269 ncCheckDataMode(groupId);
1270 if (getType().isNonPrimitive())
1271 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1272 else
1273 ncCheck(nc_put_varm_ulonglong(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1274}
1275// Writes a mapped array section of values into the netCDF variable.
1276void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const char** dataValues) const {
1277 ncCheckDataMode(groupId);
1278 if (getType().isNonPrimitive())
1279 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1280 else
1281 ncCheck(nc_put_varm_string(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1282}
1283// Writes a mapped array section of values into the netCDF variable with no data conversion.
1284void NcVar::putVar(const vector<size_t>& startp, const vector<size_t>&countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, const void* dataValues) const {
1285 ncCheckDataMode(groupId);
1286 ncCheck(nc_put_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1287}
1288
1289
1290
1291
1292
1293// Data reading
1294
1295
1296
1297// Reads the entire data of the netCDF variable.
1298void NcVar::getVar(char* dataValues) const {
1299 if (getType().isNonPrimitive())
1300 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1301 else
1302 ncCheck(nc_get_var_text(groupId, myId,dataValues),__FILE__,__LINE__);
1303}
1304// Reads the entire data of the netCDF variable.
1305void NcVar::getVar(unsigned char* dataValues) const {
1306 if (getType().isNonPrimitive())
1307 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1308 else
1309 ncCheck(nc_get_var_uchar(groupId, myId,dataValues),__FILE__,__LINE__);
1310}
1311// Reads the entire data of the netCDF variable.
1312void NcVar::getVar(signed char* dataValues) const {
1313 if (getType().isNonPrimitive())
1314 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1315 else
1316 ncCheck(nc_get_var_schar(groupId, myId,dataValues),__FILE__,__LINE__);
1317}
1318// Reads the entire data of the netCDF variable.
1319void NcVar::getVar(short* dataValues) const {
1320 if (getType().isNonPrimitive())
1321 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1322 else
1323 ncCheck(nc_get_var_short(groupId, myId,dataValues),__FILE__,__LINE__);
1324}
1325// Reads the entire data of the netCDF variable.
1326void NcVar::getVar(int* dataValues) const {
1327 if (getType().isNonPrimitive())
1328 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1329 else
1330 ncCheck(nc_get_var_int(groupId, myId,dataValues),__FILE__,__LINE__);
1331}
1332// Reads the entire data of the netCDF variable.
1333void NcVar::getVar(long* dataValues) const {
1334 if (getType().isNonPrimitive())
1335 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1336 else
1337 ncCheck(nc_get_var_long(groupId, myId,dataValues),__FILE__,__LINE__);
1338}
1339// Reads the entire data of the netCDF variable.
1340void NcVar::getVar(float* dataValues) const {
1341 if (getType().isNonPrimitive())
1342 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1343 else
1344 ncCheck(nc_get_var_float(groupId, myId,dataValues),__FILE__,__LINE__);
1345}
1346// Reads the entire data of the netCDF variable.
1347void NcVar::getVar(double* dataValues) const {
1348 if (getType().isNonPrimitive())
1349 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1350 else
1351 ncCheck(nc_get_var_double(groupId, myId,dataValues),__FILE__,__LINE__);
1352}
1353// Reads the entire data of the netCDF variable.
1354void NcVar::getVar(unsigned short* dataValues) const {
1355 if (getType().isNonPrimitive())
1356 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1357 else
1358 ncCheck(nc_get_var_ushort(groupId, myId,dataValues),__FILE__,__LINE__);
1359}
1360// Reads the entire data of the netCDF variable.
1361void NcVar::getVar(unsigned int* dataValues) const {
1362 if (getType().isNonPrimitive())
1363 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1364 else
1365 ncCheck(nc_get_var_uint(groupId, myId,dataValues),__FILE__,__LINE__);
1366}
1367// Reads the entire data of the netCDF variable.
1368void NcVar::getVar(long long* dataValues) const {
1369 if (getType().isNonPrimitive())
1370 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1371 else
1372 ncCheck(nc_get_var_longlong(groupId, myId,dataValues),__FILE__,__LINE__);
1373}
1374// Reads the entire data of the netCDF variable.
1375void NcVar::getVar(unsigned long long* dataValues) const {
1376 if (getType().isNonPrimitive())
1377 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1378 else
1379 ncCheck(nc_get_var_ulonglong(groupId, myId,dataValues),__FILE__,__LINE__);
1380}
1381// Reads the entire data of the netCDF variable.
1382void NcVar::getVar(char** dataValues) const {
1383 if (getType().isNonPrimitive())
1384 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1385 else
1386 ncCheck(nc_get_var_string(groupId, myId,dataValues),__FILE__,__LINE__);
1387}
1388// Reads the entire data of the netCDF variable with no data conversion.
1389void NcVar::getVar(void* dataValues) const {
1390 ncCheck(nc_get_var(groupId, myId,dataValues),__FILE__,__LINE__);
1391}
1392
1393
1394
1396
1397// Reads a single datum value of a netCDF variable.
1398void NcVar::getVar(const vector<size_t>& index, char* datumValue) const {
1399 if (getType().isNonPrimitive())
1400 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1401 else
1402 ncCheck(nc_get_var1_text(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1403}
1404// Reads a single datum value of a netCDF variable.
1405void NcVar::getVar(const vector<size_t>& index, unsigned char* datumValue) const {
1406 if (getType().isNonPrimitive())
1407 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1408 else
1409 ncCheck(nc_get_var1_uchar(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1410}
1411// Reads a single datum value of a netCDF variable.
1412void NcVar::getVar(const vector<size_t>& index, signed char* datumValue) const {
1413 if (getType().isNonPrimitive())
1414 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1415 else
1416 ncCheck(nc_get_var1_schar(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1417}
1418// Reads a single datum value of a netCDF variable.
1419void NcVar::getVar(const vector<size_t>& index, short* datumValue) const {
1420 if (getType().isNonPrimitive())
1421 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1422 else
1423 ncCheck(nc_get_var1_short(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1424}
1425// Reads a single datum value of a netCDF variable.
1426void NcVar::getVar(const vector<size_t>& index, int* datumValue) const {
1427 if (getType().isNonPrimitive())
1428 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1429 else
1430 ncCheck(nc_get_var1_int(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1431}
1432// Reads a single datum value of a netCDF variable.
1433void NcVar::getVar(const vector<size_t>& index, long* datumValue) const {
1434 if (getType().isNonPrimitive())
1435 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1436 else
1437 ncCheck(nc_get_var1_long(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1438}
1439// Reads a single datum value of a netCDF variable.
1440void NcVar::getVar(const vector<size_t>& index, float* datumValue) const {
1441 if (getType().isNonPrimitive())
1442 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1443 else
1444 ncCheck(nc_get_var1_float(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1445}
1446// Reads a single datum value of a netCDF variable.
1447void NcVar::getVar(const vector<size_t>& index, double* datumValue) const {
1448 if (getType().isNonPrimitive())
1449 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1450 else
1451 ncCheck(nc_get_var1_double(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1452}
1453// Reads a single datum value of a netCDF variable.
1454void NcVar::getVar(const vector<size_t>& index, unsigned short* datumValue) const {
1455 if (getType().isNonPrimitive())
1456 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1457 else
1458 ncCheck(nc_get_var1_ushort(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1459}
1460// Reads a single datum value of a netCDF variable.
1461void NcVar::getVar(const vector<size_t>& index, unsigned int* datumValue) const {
1462 if (getType().isNonPrimitive())
1463 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1464 else
1465 ncCheck(nc_get_var1_uint(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1466}
1467// Reads a single datum value of a netCDF variable.
1468void NcVar::getVar(const vector<size_t>& index, long long* datumValue) const {
1469 if (getType().isNonPrimitive())
1470 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1471 else
1472 ncCheck(nc_get_var1_longlong(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1473}
1474// Reads a single datum value of a netCDF variable
1475void NcVar::getVar(const vector<size_t>& index, unsigned long long* datumValue) const {
1476 if (getType().isNonPrimitive())
1477 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1478 else
1479 ncCheck(nc_get_var1_ulonglong(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1480}
1481// Reads a single datum value of a netCDF variable.
1482void NcVar::getVar(const vector<size_t>& index, char** datumValue) const {
1483 if (getType().isNonPrimitive())
1484 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1485 else
1486 ncCheck(nc_get_var1_string(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1487}
1488// Reads a single datum value of a netCDF variable with no data conversion.
1489void NcVar::getVar(const vector<size_t>& index, void* datumValue) const {
1490 ncCheck(nc_get_var1(groupId, myId,&index[0],datumValue),__FILE__,__LINE__);
1491}
1492
1493
1494
1496
1497// Reads an array of values from a netCDF variable.
1498void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, char* dataValues) const {
1499 if (getType().isNonPrimitive())
1500 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1501 else
1502 ncCheck(nc_get_vara_text(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1503}
1504// Reads an array of values from a netCDF variable.
1505void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, unsigned char* dataValues) const {
1506 if (getType().isNonPrimitive())
1507 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1508 else
1509 ncCheck(nc_get_vara_uchar(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1510}
1511// Reads an array of values from a netCDF variable.
1512void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, signed char* dataValues) const {
1513 if (getType().isNonPrimitive())
1514 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1515 else
1516 ncCheck(nc_get_vara_schar(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1517}
1518// Reads an array of values from a netCDF variable.
1519void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, short* dataValues) const {
1520 if (getType().isNonPrimitive())
1521 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1522 else
1523 ncCheck(nc_get_vara_short(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1524}
1525// Reads an array of values from a netCDF variable.
1526void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, int* dataValues) const {
1527 if (getType().isNonPrimitive())
1528 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1529 else
1530 ncCheck(nc_get_vara_int(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1531}
1532// Reads an array of values from a netCDF variable.
1533void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, long* dataValues) const {
1534 if (getType().isNonPrimitive())
1535 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1536 else
1537 ncCheck(nc_get_vara_long(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1538}
1539// Reads an array of values from a netCDF variable.
1540void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, float* dataValues) const {
1541 if (getType().isNonPrimitive())
1542 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1543 else
1544 ncCheck(nc_get_vara_float(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1545}
1546// Reads an array of values from a netCDF variable.
1547void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, double* dataValues) const {
1548 if (getType().isNonPrimitive())
1549 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1550 else
1551 ncCheck(nc_get_vara_double(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1552}
1553// Reads an array of values from a netCDF variable.
1554void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, unsigned short* dataValues) const {
1555 if (getType().isNonPrimitive())
1556 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1557 else
1558 ncCheck(nc_get_vara_ushort(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1559}
1560// Reads an array of values from a netCDF variable.
1561void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, unsigned int* dataValues) const {
1562 if (getType().isNonPrimitive())
1563 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1564 else
1565 ncCheck(nc_get_vara_uint(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1566}
1567// Reads an array of values from a netCDF variable.
1568void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, long long* dataValues) const {
1569 if (getType().isNonPrimitive())
1570 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1571 else
1572 ncCheck(nc_get_vara_longlong(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1573}
1574// Reads an array of values from a netCDF variable
1575void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, unsigned long long* dataValues) const {
1576 if (getType().isNonPrimitive())
1577 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1578 else
1579 ncCheck(nc_get_vara_ulonglong(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1580}
1581// Reads an array of values from a netCDF variable.
1582void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, char** dataValues) const {
1583 if (getType().isNonPrimitive())
1584 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1585 else
1586 ncCheck(nc_get_vara_string(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1587}
1588// Reads an array of values from a netCDF variable with no data conversion.
1589void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, void* dataValues) const {
1590 ncCheck(nc_get_vara(groupId, myId,&startp[0],&countp[0],dataValues),__FILE__,__LINE__);
1591}
1592
1593
1595
1596// Reads a subsampled (strided) array section of values from a netCDF variable.
1597void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, char* dataValues) const {
1598 if (getType().isNonPrimitive())
1599 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1600 else
1601 ncCheck(nc_get_vars_text(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1602}
1603// Reads a subsampled (strided) array section of values from a netCDF variable.
1604void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, unsigned char* dataValues) const {
1605 if (getType().isNonPrimitive())
1606 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1607 else
1608 ncCheck(nc_get_vars_uchar(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1609}
1610// Reads a subsampled (strided) array section of values from a netCDF variable.
1611void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, signed char* dataValues) const {
1612 if (getType().isNonPrimitive())
1613 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1614 else
1615 ncCheck(nc_get_vars_schar(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1616}
1617// Reads a subsampled (strided) array section of values from a netCDF variable.
1618void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, short* dataValues) const {
1619 if (getType().isNonPrimitive())
1620 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1621 else
1622 ncCheck(nc_get_vars_short(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1623}
1624// Reads a subsampled (strided) array section of values from a netCDF variable.
1625void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, int* dataValues) const {
1626 if (getType().isNonPrimitive())
1627 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1628 else
1629 ncCheck(nc_get_vars_int(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1630}
1631// Reads a subsampled (strided) array section of values from a netCDF variable.
1632void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, long* dataValues) const {
1633 if (getType().isNonPrimitive())
1634 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1635 else
1636 ncCheck(nc_get_vars_long(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1637}
1638// Reads a subsampled (strided) array section of values from a netCDF variable.
1639void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, float* dataValues) const {
1640 if (getType().isNonPrimitive())
1641 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1642 else
1643 ncCheck(nc_get_vars_float(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1644}
1645// Reads a subsampled (strided) array section of values from a netCDF variable.
1646void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, double* dataValues) const {
1647 if (getType().isNonPrimitive())
1648 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1649 else
1650 ncCheck(nc_get_vars_double(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1651}
1652// Reads a subsampled (strided) array section of values from a netCDF variable.
1653void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, unsigned short* dataValues) const {
1654 if (getType().isNonPrimitive())
1655 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1656 else
1657 ncCheck(nc_get_vars_ushort(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1658}
1659// Reads a subsampled (strided) array section of values from a netCDF variable.
1660void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, unsigned int* dataValues) const {
1661 if (getType().isNonPrimitive())
1662 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1663 else
1664 ncCheck(nc_get_vars_uint(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1665}
1666// Reads a subsampled (strided) array section of values from a netCDF variable.
1667void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, long long* dataValues) const {
1668 if (getType().isNonPrimitive())
1669 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1670 else
1671 ncCheck(nc_get_vars_longlong(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1672}
1673// Reads a subsampled (strided) array section of values from a netCDF variable
1674void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, unsigned long long* dataValues) const {
1675 if (getType().isNonPrimitive())
1676 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1677 else
1678 ncCheck(nc_get_vars_ulonglong(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1679}
1680// Reads a subsampled (strided) array section of values from a netCDF variable.
1681void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, char** dataValues) const {
1682 if (getType().isNonPrimitive())
1683 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1684 else
1685 ncCheck(nc_get_vars_string(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1686}
1687// Reads a subsampled (strided) array section of values from a netCDF variable with no data conversion.
1688void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, void* dataValues) const {
1689 ncCheck(nc_get_vars(groupId, myId,&startp[0],&countp[0],&stridep[0],dataValues),__FILE__,__LINE__);
1690}
1691
1692
1694
1695// Reads a mapped array section of values from a netCDF variable.
1696void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, char* dataValues) const {
1697 if (getType().isNonPrimitive())
1698 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1699 else
1700 ncCheck(nc_get_varm_text(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1701}
1702// Reads a mapped array section of values from a netCDF variable.
1703void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, unsigned char* dataValues) const {
1704 if (getType().isNonPrimitive())
1705 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1706 else
1707 ncCheck(nc_get_varm_uchar(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1708}
1709// Reads a mapped array section of values from a netCDF variable.
1710void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, signed char* dataValues) const {
1711 if (getType().isNonPrimitive())
1712 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1713 else
1714 ncCheck(nc_get_varm_schar(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1715}
1716// Reads a mapped array section of values from a netCDF variable.
1717void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, short* dataValues) const {
1718 if (getType().isNonPrimitive())
1719 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1720 else
1721 ncCheck(nc_get_varm_short(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1722}
1723// Reads a mapped array section of values from a netCDF variable.
1724void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, int* dataValues) const {
1725 if (getType().isNonPrimitive())
1726 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1727 else
1728 ncCheck(nc_get_varm_int(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1729}
1730// Reads a mapped array section of values from a netCDF variable.
1731void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, long* dataValues) const {
1732 if (getType().isNonPrimitive())
1733 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1734 else
1735 ncCheck(nc_get_varm_long(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1736}
1737// Reads a mapped array section of values from a netCDF variable.
1738void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, float* dataValues) const {
1739 if (getType().isNonPrimitive())
1740 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1741 else
1742 ncCheck(nc_get_varm_float(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1743}
1744// Reads a mapped array section of values from a netCDF variable.
1745void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, double* dataValues) const {
1746 if (getType().isNonPrimitive())
1747 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1748 else
1749 ncCheck(nc_get_varm_double(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1750}
1751// Reads a mapped array section of values from a netCDF variable.
1752void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, unsigned short* dataValues) const {
1753 NcType::ncType typeClass(getType().getTypeClass());
1754 if(typeClass == NcType::nc_VLEN ||typeClass == NcType::nc_OPAQUE || typeClass == NcType::nc_ENUM || typeClass == NcType::nc_COMPOUND)
1755 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1756 else
1757 ncCheck(nc_get_varm_ushort(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1758}
1759// Reads a mapped array section of values from a netCDF variable.
1760void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, unsigned int* dataValues) const {
1761 if (getType().isNonPrimitive())
1762 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1763 else
1764 ncCheck(nc_get_varm_uint(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1765}
1766// Reads a mapped array section of values from a netCDF variable.
1767void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, long long* dataValues) const {
1768 if (getType().isNonPrimitive())
1769 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1770 else
1771 ncCheck(nc_get_varm_longlong(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1772}
1773// Reads a mapped array section of values from a netCDF variable
1774void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, unsigned long long* dataValues) const {
1775 if (getType().isNonPrimitive())
1776 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1777 else
1778 ncCheck(nc_get_varm_ulonglong(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1779}
1780// Reads a mapped array section of values from a netCDF variable.
1781void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, char** dataValues) const {
1782 if (getType().isNonPrimitive())
1783 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1784 else
1785 ncCheck(nc_get_varm_string(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1786}
1787// Reads a mapped array section of values from a netCDF variable with no data conversion.
1788void NcVar::getVar(const vector<size_t>& startp, const vector<size_t>& countp, const vector<ptrdiff_t>& stridep, const vector<ptrdiff_t>& imapp, void* dataValues) const {
1789 ncCheck(nc_get_varm(groupId, myId,&startp[0],&countp[0],&stridep[0],&imapp[0],dataValues),__FILE__,__LINE__);
1790}
std::string getName() const
Get the attribute name.
Definition ncAtt.h:30
Class represents a netCDF dimension.
Definition ncDim.h:13
Class represents a netCDF group.
Definition ncGroup.h:26
NcGroup()
Constructor generates a null object.
Definition ncGroup.cpp:52
@ ParentsAndCurrent
Select from contents of current and parents groups.
Definition ncGroup.h:51
Base class inherited by NcOpaque, NcVlen, NcCompound and NcEnum classes.
Definition ncType.h:15
NcType()
Constructor generates a null object.
Definition ncType.cpp:43
bool isNonPrimitive() const
Return true if this is not a primitive type.
Definition ncType.cpp:163
ncType
List of netCDF types that can be represented.
Definition ncType.h:26
@ nc_OPAQUE
"NcOpaque type"
Definition ncType.h:40
@ nc_VLEN
"NcVlen type"
Definition ncType.h:39
@ nc_ENUM
"NcEnum type"
Definition ncType.h:41
@ nc_COMPOUND
"NcCompound type"
Definition ncType.h:42
nc_type getId() const
The netCDF Id of this type.
Definition ncType.h:88
Class represents a netCDF attribute local to a netCDF variable.
Definition ncVarAtt.h:14
NcVarAtt()
Constructor generates a null object.
Definition ncVarAtt.cpp:42
void freeString(size_t len, char **data) const
Free memory allocated for a string.
Definition ncVar.cpp:646
ChecksumMode getChecksum() const
Gets the checksum parameters of the variable.
Definition ncVar.cpp:695
bool operator!=(const NcVar &rhs) const
!= operator
Definition ncVar.cpp:54
void setChecksum(ChecksumMode checksumMode) const
Sets the checksum parameters of a variable.
Definition ncVar.cpp:689
ChunkMode
Used for chunking specifications (see NcVar::setChunking, NcVar::getChunkingParameters).
Definition ncVar.h:39
void getFilter(unsigned int *idp, size_t *nparamsp, unsigned int *params) const
Query filter properties (if a filter has been applied).
Definition ncVar.cpp:634
NcGroup getParentGroup() const
Gets parent group.
Definition ncVar.cpp:81
NcDim getDim(int i) const
Gets the i'th NcDim object.
Definition ncVar.cpp:172
void getCompressionParameters(bool &shuffleFilterEnabled, bool &deflateFilterEnabled, int &deflateLevel) const
Gets the compression parameters.
Definition ncVar.cpp:614
NcVarAtt putAtt(const std::string &name, size_t len, const char **dataValues) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
void getTypeLen(nc_type type) const
Query the length of a given ncType.
Definition ncVar.cpp:640
void setCompression(bool enableShuffleFilter, bool enableDeflateFilter, int deflateLevel) const
Sets the compression parameters.
Definition ncVar.cpp:601
EndianMode getEndianness() const
Gets the endianness of the variable.
Definition ncVar.cpp:672
std::string getName() const
Name of this NcVar object.
Definition ncVar.cpp:528
void rename(const std::string &newname) const
Rename the variable.
Definition ncVar.cpp:710
ChecksumMode
Used for checksum specification (see NcVar::setChecksum, NcVar::getChecksum).
Definition ncVar.h:63
int getDimCount() const
The the number of dimensions.
Definition ncVar.cpp:143
void getFillModeParameters(bool &fillMode, void *fillValue=NULL) const
This is an overloaded member function, provided for convenience.
Definition ncVar.cpp:585
int getId() const
Get the variable id.
Definition ncVar.cpp:87
NcVar & operator=(const NcVar &rhs)
assignment operator
Definition ncVar.cpp:30
void getVar(void *dataValues) const
This is an overloaded member function, provided for convenience.
Definition ncVar.cpp:1389
void setChunkCache(size_t size, size_t nelems, float preemption) const
Change cache setttings for a chunked variable.
Definition ncVar.cpp:652
bool operator==(const NcVar &rhs) const
equivalence operator
Definition ncVar.cpp:47
NcVarAtt getAtt(const std::string &name) const
Gets attribute by name.
Definition ncVar.cpp:212
void putVar(const void *dataValues) const
This is an overloaded member function, provided for convenience.
Definition ncVar.cpp:830
void setEndianness(EndianMode endianMode) const
Sets the endianness of the variable.
Definition ncVar.cpp:665
std::map< std::string, NcVarAtt > getAtts() const
Gets the set of attributes.
Definition ncVar.cpp:197
void setFilter(unsigned int id, size_t nparams, const unsigned int *parms) const
Define new variable for compression/decompression.
Definition ncVar.cpp:627
NcVar()
Constructor generates a null object.
Definition ncVar.cpp:66
void setChunking(ChunkMode chunkMode, std::vector< size_t > &chunksizes) const
Sets chunking parameters.
Definition ncVar.cpp:543
NcType getType() const
Returns the variable type.
Definition ncVar.cpp:97
bool isNull() const
Returns true if this object variable is not defined.
Definition ncVar.h:126
void setFill(bool fillMode, void *fillValue=NULL) const
This is an overloaded member function, provided for convenience. It differs from the above function o...
Definition ncVar.cpp:569
friend bool operator>(const NcVar &lhs, const NcVar &rhs)
comparator operator
Definition ncVar.cpp:21
std::vector< NcDim > getDims() const
Gets the set of NcDim objects.
Definition ncVar.cpp:152
EndianMode
Used to specifying the endianess of the data, (see NcVar::setEndianness, NcVar::getEndianness).
Definition ncVar.h:55
friend bool operator<(const NcVar &lhs, const NcVar &rhs)
comparator operator
Definition ncVar.cpp:15
int getAttCount() const
Gets the number of attributes.
Definition ncVar.cpp:188
void getChunkingParameters(ChunkMode &chunkMode, std::vector< size_t > &chunkSizes) const
Gets the chunking parameters.
Definition ncVar.cpp:550
Base object is thrown if a netCDF exception is encountered.
Definition ncException.h:24
Exception classes.
Definition ncException.h:16
C++ API for netCDF4.
Definition ncAtt.h:10
void ncCheckDataMode(int ncid)
Function checks if the file (group) is in data mode.
Definition ncCheck.cpp:89
NcShort ncShort
A global instance of the NcShort class within the netCDF namespace.
Definition ncShort.cpp:7
NcFloat ncFloat
A global instance of the NcFloat class within the netCDF namespace.
Definition ncFloat.cpp:7
NcInt64 ncInt64
A global instance of the NcInt64 class within the netCDF namespace.
Definition ncInt64.cpp:7
void ncCheckDefineMode(int ncid)
Function checks if the file (group) is in define mode.
Definition ncCheck.cpp:83
NcUint64 ncUint64
A global instance of the NcUint64 class within the netCDF namespace.
Definition ncUint64.cpp:7
NcUint ncUint
A global instance of the NcUint class within the netCDF namespace.
Definition ncUint.cpp:7
NcString ncString
A global instance of the NcString class within the netCDF namespace.
Definition ncString.cpp:7
NcInt ncInt
A global instance of the NcInt class within the netCDF namespace.
Definition ncInt.cpp:7
NcDouble ncDouble
A global instance of the NcDouble class within the netCDF namespace.
Definition ncDouble.cpp:7
void ncCheck(int retCode, const char *file, int line)
Function checks error code and if necessary throws an exception.
Definition ncCheck.cpp:11
NcUbyte ncUbyte
A global instance of the NcUbyte class within the netCDF namespace.
Definition ncUbyte.cpp:7
NcChar ncChar
A global instance of the NcChar class within the netCDF namespace.
Definition ncChar.cpp:7
NcByte ncByte
A global instance of the NcByte class within the netCDF namespace.
Definition ncByte.cpp:7

Return to the Main Unidata NetCDF page.
Generated on for NetCDF-C++. NetCDF is a Unidata library.