libdap Updated for version 3.21.0
libdap4 is an implementation of OPeNDAP's DAP protocol.
Vector.h
1
2// -*- mode: c++; c-basic-offset:4 -*-
3
4// This file is part of libdap, A C++ implementation of the OPeNDAP Data
5// Access Protocol.
6
7// Copyright (c) 2002,2003 OPeNDAP, Inc.
8// Author: James Gallagher <jgallagher@opendap.org>
9//
10// This library is free software; you can redistribute it and/or
11// modify it under the terms of the GNU Lesser General Public
12// License as published by the Free Software Foundation; either
13// version 2.1 of the License, or (at your option) any later version.
14//
15// This library is distributed in the hope that it will be useful,
16// but WITHOUT ANY WARRANTY; without even the implied warranty of
17// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18// Lesser General Public License for more details.
19//
20// You should have received a copy of the GNU Lesser General Public
21// License along with this library; if not, write to the Free Software
22// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23//
24// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
25
26// (c) COPYRIGHT URI/MIT 1995-1999
27// Please read the full copyright statement in the file COPYRIGHT_URI.
28//
29// Authors:
30// jhrg,jimg James Gallagher <jgallagher@gso.uri.edu>
31
32// This is the interface definition file for the abstract class
33// Vector. Vector is the parent class for List and Array.
34
35#ifndef _vector_h
36#define _vector_h 1
37
38#include <cassert>
39
40#ifndef _basetype_h
41#include "BaseType.h"
42#endif
43
44#ifndef _dds_h
45#include "DDS.h"
46#endif
47
48#ifndef constraint_evaluator_h
49#include "ConstraintEvaluator.h"
50#endif
51
52class Crc32;
53
54namespace libdap
55{
56
82class Vector: public BaseType
83{
84private:
85 // Add d_length_ll. This uses -1 as a sentinel value. jhrg 7/25/22
86 // If we decide to add a bool for 'no values yet' do that as a
87 // separate refactor. jhrg 7/25/22
88 int64_t d_length_ll = -1; // number of elements in the vector
89
90 int d_length = -1; // number of elements in the vector
91 BaseType *d_proto = nullptr; // element prototype for the Vector
92
93 // _buf was a pointer to void; delete[] complained. 6/4/2001 jhrg
94 char *d_buf = nullptr; // storage for cardinal data
95 vector<string> d_str; // special storage for strings. jhrg 2/11/05
96 vector<BaseType *> d_compound_buf; // storage for data in compound types (e.g., Structure)
97
98 // the number of elements we have allocated memory to store.
99 // This should be either the sizeof(buf)/width(bool constrained = false) for cardinal data
100 // or the capacity of d_str for strings or capacity of _vec.
101 unsigned int d_capacity = 0;
102 uint64_t d_capacity_ll = 0;
103
104 bool d_too_big_for_dap2 = false;
105
106 friend class MarshallerTest;
107
108 // Made these template methods private because they can't be
109 // overridden anyways (because c++...) - ndp 08/14/2015
110 template <typename T> void value_worker(T *v) const;
111 template <typename T> void value_ll_worker(T *v) const;
112 template <typename T> void value_worker(vector<unsigned int> *indices, T *b) const;
113 template <typename T> void value_ll_worker(vector<uint64_t> *indices, T *b) const;
114
115 template <typename T> bool set_value_worker(T *v, int sz);
116 template <typename T> bool set_value_ll_worker(T *v, int64_t sz);
117 template <typename T> bool set_value_worker(vector<T> &v, int sz);
118 template <typename T> bool set_value_ll_worker(vector<T> &v, int64_t sz);
119
120 bool m_is_cardinal_type() const;
121 int64_t m_create_cardinal_data_buffer_for_type(int64_t num_elements);
122 void m_delete_cardinal_data_buffer();
123 template <class CardType> void m_set_cardinal_values_internal(const CardType* fromArray, int64_t num_elements);
124
125 // This function copies the private members of Vector.
126 void m_duplicate(const Vector &v);
127
128public:
129 Vector(const string &n, BaseType *v, const Type &t, bool is_dap4 = false);
130 Vector(const string &n, const string &d, BaseType *v, const Type &t, bool is_dap4 = false);
131 Vector(const Vector &rhs);
132
133 virtual ~Vector();
134
135 Vector &operator=(const Vector &rhs);
136 // FIXME BaseType *ptr_duplicate() = 0 override;
137
146 char *get_buf() {
147 return d_buf;
148 }
149
156 vector<string> &get_str() {
157 return d_str;
158 }
159
167 vector<BaseType*> &get_compound_buf() {
168 return d_compound_buf;
169 }
170
171 virtual BaseType *prototype() const { return d_proto; }
172
178 virtual BaseType *set_prototype(BaseType *btp) { BaseType *orig = d_proto; d_proto = btp; return orig; }
179
180 void set_name(const std::string& name) override;
181
182 int element_count(bool leaves) override;
183
184 void set_send_p(bool state) override;
185
186 void set_read_p(bool state) override;
187
195 unsigned int width(bool constrained = false) const override
196 {
197 // Jose Garcia
198 assert(d_proto);
199
200 return length() * d_proto->width(constrained);
201 }
202
208 int64_t width_ll(bool constrained = false) const override
209 {
210 return length_ll() * d_proto->width_ll(constrained);
211 }
212
218 int length() const override { return d_length; }
219
226 int64_t length_ll() const override { return d_length_ll; }
227
228 void set_length(int64_t l) override;
229
230 void set_length_ll(int64_t l) override;
231
232
233 // DAP2
234 void intern_data(ConstraintEvaluator &eval, DDS &dds) override;
235 bool serialize(ConstraintEvaluator &eval, DDS &dds, Marshaller &m, bool ce_eval = true) override;
236 bool deserialize(UnMarshaller &um, DDS *dds, bool reuse = false) override;
237
238 // DAP4
239 void compute_checksum(Crc32 &checksum) override;
240 void intern_data(/*Crc32 &checksum*/) override;
241 void serialize(D4StreamMarshaller &m, DMR &dmr, bool filter = false) override;
242 void deserialize(D4StreamUnMarshaller &um, DMR &dmr) override;
243
244 unsigned int val2buf(void *val, bool reuse = false) override;
245 unsigned int buf2val(void **val) override;
246
247 uint64_t val2buf_ll(void *val, bool reuse = false);
248 uint64_t buf2val_ll(void **val);
249
250
251 void set_vec(unsigned int i, BaseType *val);
252 void set_vec_nocopy(unsigned int i, BaseType * val);
253
254 void set_vec_ll(uint64_t i, BaseType *val);
255 void set_vec_nocopy_ll(uint64_t i, BaseType * val);
256
257 void vec_resize(int l);
258 void vec_resize_ll(int64_t l);
259
260 void clear_local_data() override;
261
262
263 virtual unsigned int get_value_capacity() const;
264 virtual uint64_t get_value_capacity_ll() const;
265
266 void set_value_capacity(uint64_t l);
267 virtual void reserve_value_capacity(unsigned int numElements);
268 virtual void reserve_value_capacity();
269 virtual void reserve_value_capacity_ll(uint64_t numElements);
270 virtual void reserve_value_capacity_ll();
271
272 virtual void reserve_value_capacity_ll_byte(uint64_t numBytes);
273
274 virtual uint64_t set_value_slice_from_row_major_vector(const Vector& rowMajorData, uint64_t startElement);
275
276 virtual bool set_value(dods_byte *val, int sz);
277 virtual bool set_value(dods_int8 *val, int sz);
278 virtual bool set_value(dods_int16 *val, int sz);
279 virtual bool set_value(dods_uint16 *val, int sz);
280 virtual bool set_value(dods_int32 *val, int sz);
281 virtual bool set_value(dods_uint32 *val, int sz);
282 virtual bool set_value(dods_int64 *val, int sz);
283 virtual bool set_value(dods_uint64 *val, int sz);
284 virtual bool set_value(dods_float32 *val, int sz);
285 virtual bool set_value(dods_float64 *val, int sz);
286 virtual bool set_value(string *val, int sz);
287
288
289 virtual bool set_value_ll(dods_byte *val, int64_t sz);
290 virtual bool set_value_ll(dods_int8 *val, int64_t sz);
291 virtual bool set_value_ll(dods_int16 *val, int64_t sz);
292 virtual bool set_value_ll(dods_uint16 *val, int64_t sz);
293 virtual bool set_value_ll(dods_int32 *val, int64_t sz);
294 virtual bool set_value_ll(dods_uint32 *val, int64_t sz);
295 virtual bool set_value_ll(dods_int64 *val, int64_t sz);
296 virtual bool set_value_ll(dods_uint64 *val, int64_t sz);
297 virtual bool set_value_ll(dods_float32 *val, int64_t sz);
298 virtual bool set_value_ll(dods_float64 *val, int64_t sz);
299 virtual bool set_value_ll(string *val, int64_t sz);
300
301 virtual bool set_value(vector<dods_byte> &val, int sz);
302 virtual bool set_value(vector<dods_int8> &val, int sz);
303 virtual bool set_value(vector<dods_int16> &val, int sz);
304 virtual bool set_value(vector<dods_uint16> &val, int sz);
305 virtual bool set_value(vector<dods_int32> &val, int sz);
306 virtual bool set_value(vector<dods_uint32> &val, int sz);
307 virtual bool set_value(vector<dods_int64> &val, int sz);
308 virtual bool set_value(vector<dods_uint64> &val, int sz);
309 virtual bool set_value(vector<dods_float32> &val, int sz);
310 virtual bool set_value(vector<dods_float64> &val, int sz);
311 virtual bool set_value(vector<string> &val, int sz);
312
313 virtual bool set_value_ll(vector<dods_byte> &val, int64_t sz);
314 virtual bool set_value_ll(vector<dods_int8> &val, int64_t sz);
315 virtual bool set_value_ll(vector<dods_int16> &val, int64_t sz);
316 virtual bool set_value_ll(vector<dods_uint16> &val, int64_t sz);
317 virtual bool set_value_ll(vector<dods_int32> &val, int64_t sz);
318 virtual bool set_value_ll(vector<dods_uint32> &val, int64_t sz);
319 virtual bool set_value_ll(vector<dods_int64> &val, int64_t sz);
320 virtual bool set_value_ll(vector<dods_uint64> &val, int64_t sz);
321 virtual bool set_value_ll(vector<dods_float32> &val, int64_t sz);
322 virtual bool set_value_ll(vector<dods_float64> &val, int64_t sz);
323 virtual bool set_value_ll(vector<string> &val, int64_t sz);
324
325
326
327 virtual void value(dods_byte *b) const;
328 virtual void value(dods_int8 *b) const;
329 virtual void value(dods_int16 *b) const;
330 virtual void value(dods_uint16 *b) const;
331 virtual void value(dods_int32 *b) const;
332 virtual void value(dods_uint32 *b) const;
333 virtual void value(dods_int64 *b) const;
334 virtual void value(dods_uint64 *b) const;
335 virtual void value(dods_float32 *b) const;
336 virtual void value(dods_float64 *b) const;
337 virtual void value(vector<string> &b) const;
338
339 virtual void value(vector<unsigned int> *indices, dods_byte *b) const;
340 virtual void value(vector<unsigned int> *indices, dods_int8 *b) const;
341 virtual void value(vector<unsigned int> *indices, dods_int16 *b) const;
342 virtual void value(vector<unsigned int> *indices, dods_uint16 *b) const;
343 virtual void value(vector<unsigned int> *indices, dods_int32 *b) const;
344 virtual void value(vector<unsigned int> *indices, dods_uint32 *b) const;
345 virtual void value(vector<unsigned int> *indices, dods_int64 *b) const;
346 virtual void value(vector<unsigned int> *indices, dods_uint64 *b) const;
347 virtual void value(vector<unsigned int> *indices, dods_float32 *b) const;
348 virtual void value(vector<unsigned int> *indices, dods_float64 *b) const;
349 virtual void value(vector<unsigned int> *index, vector<string> &b) const;
350
351 virtual void value_ll(vector<uint64_t> *indices, dods_byte *b) const;
352 virtual void value_ll(vector<uint64_t> *indices, dods_int8 *b) const;
353 virtual void value_ll(vector<uint64_t> *indices, dods_int16 *b) const;
354 virtual void value_ll(vector<uint64_t> *indices, dods_uint16 *b) const;
355 virtual void value_ll(vector<uint64_t> *indices, dods_int32 *b) const;
356 virtual void value_ll(vector<uint64_t> *indices, dods_uint32 *b) const;
357 virtual void value_ll(vector<uint64_t> *indices, dods_int64 *b) const;
358 virtual void value_ll(vector<uint64_t> *indices, dods_uint64 *b) const;
359 virtual void value_ll(vector<uint64_t> *indices, dods_float32 *b) const;
360 virtual void value_ll(vector<uint64_t> *indices, dods_float64 *b) const;
361 virtual void value_ll(vector<uint64_t> *index, vector<string> &b) const;
362
363
364 virtual void *value();
365
366 BaseType *var(const string &name = "", bool exact_match = true, btp_stack *s = nullptr) override;
367 BaseType *var(const string &name, btp_stack &s) override;
368
369 virtual BaseType *var(unsigned int i);
370 virtual BaseType *var_ll(uint64_t i);
371
372 void add_var(BaseType *v, Part p = nil) override;
373 void add_var_nocopy(BaseType *v, Part p = nil) override;
374
375 bool check_semantics(string &msg, bool all = false) override;
376
377 bool is_dap4_projected(std::vector<std::string> &projected_dap4_inventory) override;
378
379 void dump(ostream &strm) const override;
380};
381
382} // namespace libdap
383
384#endif /* _vector_h */
Definition crc.h:77
The basic data type for the DODS DAP types.
Definition BaseType.h:120
virtual string name() const
Returns the name of the class instance.
Definition BaseType.cc:317
virtual unsigned int width(bool constrained=false) const
How many bytes does this variable use Return the number of bytes of storage this variable uses....
Definition BaseType.cc:1305
Evaluate a constraint expression.
Marshaller that knows how to marshal/serialize dap data objects to a C++ iostream using DAP4's receiv...
Read data from the stream made by D4StreamMarshaller.
abstract base class used to marshal/serialize dap data objects
Definition Marshaller.h:50
abstract base class used to unmarshall/deserialize dap data objects
Holds a one-dimensional collection of DAP2 data types.
Definition Vector.h:83
unsigned int width(bool constrained=false) const override
Returns the width of the data, in bytes.
Definition Vector.h:195
virtual void reserve_value_capacity_ll_byte(uint64_t numBytes)
Definition Vector.cc:1867
bool deserialize(UnMarshaller &um, DDS *dds, bool reuse=false) override
Receive data from the net.
Definition Vector.cc:855
void set_send_p(bool state) override
Indicates that the data is ready to send.
Definition Vector.cc:363
int64_t width_ll(bool constrained=false) const override
Return the number of bytes needed to hold the array data.
Definition Vector.h:208
void dump(ostream &strm) const override
dumps information about this object
Definition Vector.cc:2665
virtual BaseType * set_prototype(BaseType *btp)
Change the Vector/Array element type.
Definition Vector.h:178
void compute_checksum(Crc32 &checksum) override
include the data for this variable in the checksum DAP4 includes a checksum with every data response....
Definition Vector.cc:959
vector< BaseType * > & get_compound_buf()
Definition Vector.h:167
virtual unsigned int get_value_capacity() const
Definition Vector.cc:1700
void set_vec_nocopy(unsigned int i, BaseType *val)
Sets element i to value val. Set the ith element to val. Extend the vector if needed.
Definition Vector.cc:1606
friend class MarshallerTest
Conditionally set to true in set_length_ll()
Definition Vector.h:106
void add_var(BaseType *v, Part p=nil) override
Add the BaseType pointer to this constructor type instance.
Definition Vector.cc:2552
int length() const override
Returns the number of elements in the vector. Note that some child classes of Vector use the length o...
Definition Vector.h:218
int64_t length_ll() const override
Get the number of elements in this Vector/Array This version of the function deprecates length() whic...
Definition Vector.h:226
void set_read_p(bool state) override
Indicates that the data is ready to send.
Definition Vector.cc:400
int element_count(bool leaves) override
Count the members of constructor types.
Definition Vector.cc:342
void set_length_ll(int64_t l) override
Set the number of elements in this Vector/Array This version of the function deprecates set_length() ...
Definition Vector.cc:446
void set_vec(unsigned int i, BaseType *val)
Sets element i to value val.
Definition Vector.cc:1585
bool is_dap4_projected(std::vector< std::string > &projected_dap4_inventory) override
Definition Vector.cc:2631
void set_name(const std::string &name) override
Sets the name of the class instance.
Definition Vector.cc:332
bool check_semantics(string &msg, bool all=false) override
Compare an object's current state with the semantics of its type.
Definition Vector.cc:2619
void intern_data() override
Read data into this variable.
Definition Vector.cc:1001
virtual void reserve_value_capacity_ll()
Definition Vector.cc:1856
unsigned int val2buf(void *val, bool reuse=false) override
Reads data into the Vector buffer.
Definition Vector.cc:1329
char * get_buf()
Definition Vector.h:146
BaseType * var(const string &name="", bool exact_match=true, btp_stack *s=nullptr) override
Definition Vector.cc:486
virtual uint64_t set_value_slice_from_row_major_vector(const Vector &rowMajorData, uint64_t startElement)
Definition Vector.cc:1901
virtual void * value()
Definition Vector.cc:2527
bool serialize(ConstraintEvaluator &eval, DDS &dds, Marshaller &m, bool ce_eval=true) override
Serialize a Vector.
Definition Vector.cc:752
vector< string > & get_str()
Definition Vector.h:156
void vec_resize(int l)
Definition Vector.cc:637
virtual void reserve_value_capacity()
Definition Vector.cc:1780
unsigned int buf2val(void **val) override
Copies data from the Vector buffer.
Definition Vector.cc:1452
void clear_local_data() override
Definition Vector.cc:1672
void set_length(int64_t l) override
Sets the length of the vector. This function does not allocate any new space.
Definition Vector.cc:434
top level DAP object to house generic methods
Definition AISConnect.cc:30
Type
Identifies the data type.
Definition Type.h:94
Part
Names the parts of multi-section constructor data types.
Definition Type.h:48