libdap++
Updated for version 3.8.2
Main Page
Related Pages
Namespaces
Classes
Files
File List
File Members
Byte.cc
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
//
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23
//
24
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
25
26
// (c) COPYRIGHT URI/MIT 1994-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
// Implementation for Byte.
33
//
34
// jhrg 9/7/94
35
36
37
#include "
config.h
"
38
39
static
char
rcsid[]
not_used
=
40
{
"$Id: Byte.cc 21699 2009-11-05 00:06:01Z jimg $"
41
};
42
43
#include "
Byte.h
"
44
#include "
Int16.h
"
45
#include "
UInt16.h
"
46
#include "
Int32.h
"
47
#include "
UInt32.h
"
48
#include "
Float32.h
"
49
#include "
Float64.h
"
50
#include "
Str.h
"
51
#include "
Url.h
"
52
#include "
Array.h
"
53
#include "
Structure.h
"
54
#include "
Sequence.h
"
55
#include "
Grid.h
"
56
57
#include "
DDS.h
"
58
#include "
Operators.h
"
59
60
#include "
util.h
"
61
#include "
parser.h
"
62
#include "
dods-limits.h
"
63
#include "
InternalErr.h
"
64
65
using
std::cerr;
66
using
std::endl;
67
68
namespace
libdap {
69
79
Byte::Byte
(
const
string
& n):
BaseType
(n,
dods_byte_c
)
80
{}
81
92
Byte::Byte
(
const
string
&n,
const
string
&d):
BaseType
(n, d,
dods_byte_c
)
93
{}
94
95
Byte::Byte
(
const
Byte
& copy_from):
BaseType
(copy_from)
96
{
97
_buf
= copy_from.
_buf
;
98
}
99
100
BaseType
*
Byte::ptr_duplicate
()
101
{
102
return
new
Byte
(*
this
);
103
}
104
105
Byte
&
Byte::operator=
(
const
Byte
& rhs)
106
{
107
if
(
this
== &rhs)
108
return
*
this
;
109
110
dynamic_cast <
BaseType
& >(*this) = rhs;
111
112
_buf
= rhs.
_buf
;
113
114
return
*
this
;
115
}
116
117
unsigned
int
Byte::width
()
118
{
119
return
sizeof
(
dods_byte
);
120
}
121
132
bool
Byte::serialize
(
ConstraintEvaluator
& eval,
DDS
& dds,
133
Marshaller
&m,
bool
ce_eval)
134
{
135
dds.
timeout_on
();
136
137
if
(!
read_p
())
138
read
();
// read() throws Error and InternalErr
139
140
#if EVAL
141
if
(ce_eval && !eval.
eval_selection
(dds,
dataset
()))
142
return
true
;
143
#endif
144
145
dds.
timeout_off
();
146
147
m.
put_byte
(
_buf
) ;
148
149
return
true
;
150
}
151
155
bool
Byte::deserialize
(
UnMarshaller
&um,
DDS
*,
bool
)
156
{
157
um.
get_byte
(
_buf
) ;
158
159
return
false
;
160
}
161
167
unsigned
int
Byte::val2buf
(
void
*val,
bool
)
168
{
169
// Jose Garcia
170
// This method is public therefore and I believe it has being designed
171
// to be use by read which must be implemented on the surrogate library,
172
// thus if the pointer val is NULL, is an Internal Error.
173
if
(!val)
174
throw
InternalErr
(
"the incoming pointer does not contain any data."
);
175
176
_buf
= *(
dods_byte
*) val;
177
178
return
width
();
179
}
180
181
unsigned
int
Byte::buf2val
(
void
**val)
182
{
183
// Jose Garcia
184
// The same comment justifying throwing an Error in val2buf applies here.
185
if
(!val)
186
throw
InternalErr
(
"NULL pointer"
);
187
188
if
(!*val)
189
*val =
new
dods_byte
;
190
191
*(
dods_byte
*) * val =
_buf
;
192
193
return
width
();
194
}
195
200
bool
Byte::set_value
(
dods_byte
value)
201
{
202
_buf
=
value
;
203
set_read_p
(
true
);
204
205
return
true
;
206
}
207
210
dods_byte
Byte::value
()
const
211
{
212
return
_buf
;
213
}
214
215
#if FILE_METHODS
216
void
Byte::print_val
(FILE * out,
string
space,
bool
print_decl_p)
217
{
218
if
(print_decl_p) {
219
print_decl
(out, space,
false
);
220
fprintf(out,
" = %d;\n"
, (
int
)
_buf
);
221
}
222
else
223
fprintf(out,
"%d"
, (
int
)
_buf
);
224
}
225
#endif
226
227
void
Byte::print_val
(ostream &out,
string
space,
bool
print_decl_p)
228
{
229
if
(print_decl_p) {
230
print_decl
(out, space,
false
);
231
out <<
" = "
<< (int)
_buf
<<
";\n"
;
232
}
233
else
234
out << (int)
_buf
;
235
}
236
237
bool
Byte::ops
(
BaseType
* b,
int
op)
238
{
239
240
// Extract the Byte arg's value.
241
if
(!
read_p
() && !
read
()) {
242
// Jose Garcia
243
// Since the read method is virtual and implemented outside
244
// libdap++ if we cannot read the data that is the problem
245
// of the user or of whoever wrote the surrogate library
246
// implementing read therefore it is an internal error.
247
throw
InternalErr
(
"This value not read!"
);
248
}
249
// Extract the second arg's value.
250
if
(!b || !(b->
read_p
() || b->
read
())) {
251
// Jose Garcia
252
// Since the read method is virtual and implemented outside
253
// libdap++ if we cannot read the data that is the problem
254
// of the user or of whoever wrote the surrogate library
255
// implementing read therefore it is an internal error.
256
throw
InternalErr
(
"This value not read!"
);
257
}
258
259
switch
(b->
type
()) {
260
case
dods_byte_c
:
261
return
rops < dods_byte, dods_byte, Cmp < dods_byte, dods_byte > >
262
(
_buf
, dynamic_cast <
Byte
* >(b)->_buf, op);
263
case
dods_int16_c
:
264
return
rops
<
dods_byte
,
dods_int16
,
USCmp
<
dods_byte
,
265
dods_int16 > > (
_buf
, dynamic_cast <
Int16
* >(b)->_buf, op);
266
case
dods_uint16_c
:
267
return
rops
<
dods_byte
,
dods_uint16
,
Cmp
<
dods_byte
,
268
dods_uint16 > > (
_buf
, dynamic_cast <
UInt16
* >(b)->_buf, op);
269
case
dods_int32_c
:
270
return
rops
<
dods_byte
,
dods_int32
,
USCmp
<
dods_byte
,
271
dods_int32 > > (
_buf
, dynamic_cast <
Int32
* >(b)->_buf, op);
272
case
dods_uint32_c
:
273
return
rops
<
dods_byte
,
dods_uint32
,
Cmp
<
dods_byte
,
274
dods_uint32 > > (
_buf
, dynamic_cast <
UInt32
* >(b)->_buf, op);
275
case
dods_float32_c
:
276
return
rops
<
dods_byte
,
dods_float32
,
Cmp
<
dods_byte
,
277
dods_float32 > > (
_buf
, dynamic_cast <
Float32
* >(b)->_buf,
278
op);
279
case
dods_float64_c
:
280
return
rops
<
dods_byte
,
dods_float64
,
Cmp
<
dods_byte
,
281
dods_float64 > > (
_buf
, dynamic_cast <
Float64
* >(b)->_buf,
282
op);
283
default
:
284
return
false
;
285
}
286
}
287
296
void
Byte::dump
(ostream & strm)
const
297
{
298
strm <<
DapIndent::LMarg
<<
"Byte::dump - ("
299
<< (
void
*)
this
<<
")"
<< endl;
300
DapIndent::Indent
();
301
BaseType::dump
(strm);
302
strm <<
DapIndent::LMarg
<<
"value: "
<<
_buf
<< endl;
303
DapIndent::UnIndent
();
304
}
305
306
}
// namespace libdap
Byte.cc
Generated on Tue Mar 1 2016 20:27:20 for libdap++ by
1.8.4