libdap++  Updated for version 3.14.0
BaseType.h
Go to the documentation of this file.
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 // Dan Holloway <dan@hollywood.gso.uri.edu>
10 // Reza Nekovei <reza@intcomm.net>
11 //
12 // This library is free software; you can redistribute it and/or
13 // modify it under the terms of the GNU Lesser General Public
14 // License as published by the Free Software Foundation; either
15 // version 2.1 of the License, or (at your option) any later version.
16 //
17 // This library is distributed in the hope that it will be useful,
18 // but WITHOUT ANY WARRANTY; without even the implied warranty of
19 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 // Lesser General Public License for more details.
21 //
22 // You should have received a copy of the GNU Lesser General Public
23 // License along with this library; if not, write to the Free Software
24 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 //
26 // You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
27 
28 // (c) COPYRIGHT URI/MIT 1994-1999
29 // Please read the full copyright statement in the file COPYRIGHT_URI.
30 //
31 // Authors:
32 // jhrg,jimg James Gallagher <jgallagher@gso.uri.edu>
33 // dan Dan Holloway <dan@hollywood.gso.uri.edu>
34 // reza Reza Nekovei <reza@intcomm.net>
35 
36 // Abstract base class for the variables in a dataset. This is used to store
37 // the type-invariant information that describes a variable as given in the
38 // DODS API.
39 //
40 // jhrg 9/6/94
41 
42 #ifndef _basetype_h
43 #define _basetype_h 1
44 
45 #include <vector>
46 #include <stack>
47 #include <iostream>
48 #include <string>
49 
50 #include "AttrTable.h"
51 
52 #include "InternalErr.h"
53 
54 #include "dods-datatypes.h"
55 #include "Type.h"
56 
57 #include "DapObj.h"
58 
59 using namespace std;
60 
61 class Crc32;
62 
63 namespace libdap
64 {
65 
66 class ConstraintEvaluator;
67 
68 class DDS;
69 class Marshaller;
70 class UnMarshaller;
71 
72 class Constructor;
73 class XMLWrter;
74 
75 class DMR;
76 class D4Group;
77 class XMLWriter;
78 class D4StreamMarshaller;
79 class D4StreamUnMarshaller;
80 
81 class D4Attributes;
82 
117 class BaseType : public DapObj
118 {
119 private:
120  string d_name; // name of the instance
121  Type d_type; // instance's type
122  string d_dataset; // name of the dataset used to create this BaseType
123 
124  bool d_is_read; // true if the value has been read
125  bool d_is_send; // Is the variable in the projection?
126 
127  // d_parent points to the Constructor or Vector which holds a particular
128  // variable. It is null for simple variables. The Vector and Constructor
129  // classes must maintain this variable.
130  BaseType *d_parent;
131 
132  // Attributes for this variable. Added 05/20/03 jhrg
133  AttrTable d_attr;
134 
135  D4Attributes *d_attributes;
136 
137  bool d_is_dap4; // True if this is a DAP4 variable, false ... DAP2
138 
139  // These are non-empty only for DAP4 variables. Added 9/27/12 jhrg
140 
141 protected:
142  // These were/are used for DAP2 CEs, but not for DAP4 ones
143  bool d_in_selection; // Is the variable in the selection?
144  bool d_is_synthesized; // true if the variable is synthesized
145 
146  void m_duplicate(const BaseType &bt);
147 
148 public:
149  typedef stack<BaseType *> btp_stack;
150 
151  // These ctors assume is_dap4 is false
152  BaseType(const string &n, const Type &t, bool is_dap4 = false);
153  BaseType(const string &n, const string &d, const Type &t, bool is_dap4 = false);
154 
155  BaseType(const BaseType &copy_from);
156  virtual ~BaseType();
157 
158  virtual string toString();
159 
160  virtual BaseType *transform_to_dap4(D4Group *root, Constructor *container);
161 
162  virtual void dump(ostream &strm) const ;
163 
164  BaseType &operator=(const BaseType &rhs);
165 
166  bool is_dap4() const { return d_is_dap4; }
167  void set_is_dap4(const bool v) { d_is_dap4 = v;}
168 
175  virtual BaseType *ptr_duplicate() = 0;
176 
177  string name() const;
178  virtual void set_name(const string &n);
179  virtual std::string FQN() const;
180 
181  Type type() const;
182  void set_type(const Type &t);
183  string type_name() const;
184 
185  string dataset() const ;
186 
192  virtual int length() const { return 1; }
193 
199  virtual void set_length(int) { }
200 
201  virtual bool is_simple_type() const;
202  virtual bool is_vector_type() const;
203  virtual bool is_constructor_type() const;
204 
205  virtual bool synthesized_p();
206  virtual void set_synthesized_p(bool state);
207 
208  virtual int element_count(bool leaves = false);
209 
210  virtual bool read_p();
211  virtual void set_read_p(bool state);
212 
213  virtual bool send_p();
214  virtual void set_send_p(bool state);
215 
216  virtual AttrTable &get_attr_table();
217  virtual void set_attr_table(const AttrTable &at);
218 
219  // DAP4 attributes
220  virtual D4Attributes *attributes();
221  virtual void set_attributes(D4Attributes *);
222  virtual void set_attributes_nocopy(D4Attributes *);
223 
224  virtual bool is_in_selection();
225  virtual void set_in_selection(bool state);
226 
227  virtual void set_parent(BaseType *parent);
228  virtual BaseType *get_parent() const;
229 
230  virtual void transfer_attributes(AttrTable *at);
231 
232  // I put this comment here because the version in BaseType.cc does not
233  // include the exact_match or s variables since they are not used. Doxygen
234  // was gaging on the comment.
235 
266  virtual BaseType *var(const string &name = "", bool exact_match = true, btp_stack *s = 0);
267  virtual BaseType *var(const string &name, btp_stack &s);
268 
269  virtual void add_var(BaseType *bt, Part part = nil);
270  virtual void add_var_nocopy(BaseType *bt, Part part = nil);
271 
272  virtual bool read();
273 
274  virtual bool check_semantics(string &msg, bool all = false);
275 
276  virtual bool ops(BaseType *b, int op);
277 
278  virtual unsigned int width(bool constrained = false) const;
279 
280  virtual void print_decl(FILE *out, string space = " ",
281  bool print_semi = true,
282  bool constraint_info = false,
283  bool constrained = false);
284 
285  virtual void print_xml(FILE *out, string space = " ",
286  bool constrained = false);
287 
288  virtual void print_decl(ostream &out, string space = " ",
289  bool print_semi = true,
290  bool constraint_info = false,
291  bool constrained = false);
292 
293  virtual void print_xml(ostream &out, string space = " ",
294  bool constrained = false);
295 
296  virtual void print_xml_writer(XMLWriter &xml, bool constrained = false);
297 
298  virtual void print_dap4(XMLWriter &xml, bool constrained = false);
299 
302 #if 0
303 
314  virtual unsigned int width(bool constrained = false) = 0;
315 #endif
316 
336  virtual unsigned int buf2val(void **val) = 0;
337 
367  virtual unsigned int val2buf(void *val, bool reuse = false) = 0;
368 
381  virtual void intern_data(ConstraintEvaluator &eval, DDS &dds);
382 
410  virtual bool serialize(ConstraintEvaluator &eval, DDS &dds, Marshaller &m, bool ce_eval = true);
411 
418  virtual void compute_checksum(Crc32 &checksum) = 0;
419 
420  virtual void intern_data(Crc32 &checksum/*, DMR &dmr, ConstraintEvaluator &eval*/);
421 
433  virtual void serialize(D4StreamMarshaller &m, DMR &dmr, /*ConstraintEvaluator &eval,*/ bool filter = false);
434 
459  virtual bool deserialize(UnMarshaller &um, DDS *dds, bool reuse = false);
460 
467  virtual void deserialize(D4StreamUnMarshaller &um, DMR &dmr);
468 
484  virtual void print_val(FILE *out, string space = "",
485  bool print_decl_p = true);
486 
501  virtual void print_val(ostream &out, string space = "",
502  bool print_decl_p = true) = 0;
504 };
505 
506 } // namespace libdap
507 
508 #endif // _basetype_h
void set_is_dap4(const bool v)
Definition: BaseType.h:167
abstract base class used to unmarshall/deserialize dap data objects
Definition: UnMarshaller.h:54
Part
Names the parts of multi-section constructor data types.
Definition: Type.h:48
bool is_constructor_type(Type t)
Returns true if the instance is a constructor (i.e., Structure, Sequence or Grid) type variable...
Definition: util.cc:905
Contains the attributes for a dataset.
Definition: AttrTable.h:142
bool is_dap4() const
Definition: BaseType.h:166
Read data from the stream made by D4StreamMarshaller.
Definition: crc.h:76
bool d_in_selection
Definition: BaseType.h:143
bool is_vector_type(Type t)
Returns true if the instance is a vector (i.e., array) type variable.
Definition: util.cc:858
Type
Identifies the data type.
Definition: Type.h:94
stack< BaseType * > btp_stack
Definition: BaseType.h:149
Marshaller that knows how to marshal/serialize dap data objects to a C++ iostream using DAP4's receiv...
virtual int length() const
How many elements are in this variable.
Definition: BaseType.h:192
bool is_simple_type(Type t)
Returns true if the instance is a numeric, string or URL type variable.
Definition: util.cc:815
virtual void set_length(int)
Set the number of elements for this variable.
Definition: BaseType.h:199
Evaluate a constraint expression.
bool d_is_synthesized
Definition: BaseType.h:144
The basic data type for the DODS DAP types.
Definition: BaseType.h:117
libdap base object for common functionality of libdap objects
Definition: DapObj.h:55
abstract base class used to marshal/serialize dap data objects
Definition: Marshaller.h:53
string type_name(Type t)
Definition: util.cc:799