1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// -*- mode: c++; c-basic-offset:4 -*-
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
#ifndef _constructor_h
#define _constructor_h 1
#include <vector>
#include "BaseType.h"
class Crc32;
namespace libdap
{
class DMR;
class XMLWriter;
class D4StreamUnMarshaller;
/** Common methods for all constructor types. */
class Constructor: public BaseType
{
private:
Constructor(); // No default ctor.
protected:
std::vector<BaseType *> d_vars;
void m_duplicate(const Constructor &s);
BaseType *m_leaf_match(const string &name, btp_stack *s = 0);
BaseType *m_exact_match(const string &name, btp_stack *s = 0);
Constructor(const string &name, const Type &type, bool is_dap4 = false);
Constructor(const string &name, const string &d, const Type &type, bool is_dap4 = false);
Constructor(const Constructor ©_from);
public:
typedef std::vector<BaseType *>::const_iterator Vars_citer ;
typedef std::vector<BaseType *>::iterator Vars_iter ;
typedef std::vector<BaseType *>::reverse_iterator Vars_riter ;
virtual ~Constructor();
Constructor &operator=(const Constructor &rhs);
virtual void transform_to_dap4(D4Group *root, Constructor *dest);
virtual std::string FQN() const;
virtual int element_count(bool leaves = false);
virtual void set_send_p(bool state);
virtual void set_read_p(bool state);
virtual unsigned int width(bool constrained = false) const;
#if 0
virtual unsigned int width(bool constrained);
#endif
// TODO Rewrite these methods to use the back pointers and keep this
// for older code.
/// btp_stack no longer needed; use back pointers (BaseType::get_parent())
virtual BaseType *var(const string &name, bool exact_match = true, btp_stack *s = 0);
/// @deprecated
virtual BaseType *var(const string &n, btp_stack &s);
Vars_iter var_begin();
Vars_iter var_end();
Vars_riter var_rbegin();
Vars_riter var_rend();
Vars_iter get_vars_iter(int i);
BaseType *get_var_index(int i);
virtual void add_var(BaseType *bt, Part part = nil);
virtual void add_var_nocopy(BaseType *bt, Part part = nil);
virtual void del_var(const string &name);
virtual void del_var(Vars_iter i);
virtual bool read();
// DAP2
virtual void intern_data(ConstraintEvaluator &eval, DDS &dds);
virtual bool serialize(ConstraintEvaluator &eval, DDS &dds, Marshaller &m, bool ce_eval = true);
virtual bool deserialize(UnMarshaller &um, DDS *dds, bool reuse = false);
// DAP4
virtual void compute_checksum(Crc32 &checksum);
virtual void intern_data(/*Crc32 &checksum, DMR &dmr, ConstraintEvaluator &eval*/);
virtual void serialize(D4StreamMarshaller &m, DMR &dmr, /*ConstraintEvaluator &eval,*/ bool filter = false);
virtual void deserialize(D4StreamUnMarshaller &um, DMR &dmr);
// Do not store values in memory as for C; users work with the C++ objects
virtual unsigned int val2buf(void *, bool) {
throw InternalErr(__FILE__, __LINE__, "Never use this method; see the programmer's guide documentation.");
}
virtual unsigned int buf2val(void **) {
throw InternalErr(__FILE__, __LINE__, "Never use this method; see the programmer's guide documentation.");
}
virtual bool is_linear();
virtual void set_in_selection(bool state);
virtual void print_decl(ostream &out, string space = " ",
bool print_semi = true,
bool constraint_info = false,
bool constrained = false);
virtual void print_xml(ostream &out, string space = " ",
bool constrained = false);
void print_dap4(XMLWriter &xml, bool constrained = false);
virtual void print_xml_writer(XMLWriter &xml, bool constrained = false);
virtual void print_decl(FILE *out, string space = " ",
bool print_semi = true,
bool constraint_info = false,
bool constrained = false);
virtual void print_xml(FILE *out, string space = " ",
bool constrained = false);
virtual void print_val(FILE *out, string space = "",
bool print_decl_p = true);
virtual void print_val(ostream &out, string space = "",
bool print_decl_p = true);
virtual bool check_semantics(string &msg, bool all = false);
virtual void transfer_attributes(AttrTable *at);
static AttrTable *make_dropped_vars_attr_table(vector<BaseType *> *dropped_vars);
virtual void dump(ostream &strm) const ;
};
} // namespace libdap
#endif // _constructor_h
|
