00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #include "config.h"
00038
00039 static char rcsid[] not_used =
00040 {"$Id: Float32.cc 16444 2007-05-10 16:09:07Z jimg $"
00041 };
00042
00043 #include <stdlib.h>
00044
00045 #include "Float32.h"
00046 #include "DDS.h"
00047 #include "util.h"
00048 #include "parser.h"
00049 #include "Operators.h"
00050 #include "dods-limits.h"
00051 #include "InternalErr.h"
00052
00053
00054 using std::cerr;
00055 using std::endl;
00056
00064 Float32::Float32(const string &n)
00065 : BaseType(n, dods_float32_c, (xdrproc_t)XDR_FLOAT32)
00066 {}
00067
00068 Float32::Float32(const Float32 ©_from) : BaseType(copy_from)
00069 {
00070 _buf = copy_from._buf;
00071 }
00072
00073 BaseType *
00074 Float32::ptr_duplicate()
00075 {
00076 return new Float32(*this);
00077 }
00078
00079 Float32 &
00080 Float32::operator=(const Float32 &rhs)
00081 {
00082 if (this == &rhs)
00083 return *this;
00084
00085 dynamic_cast<BaseType &>(*this) = rhs;
00086
00087 _buf = rhs._buf;
00088
00089 return *this;
00090 }
00091
00092 unsigned int
00093 Float32::width()
00094 {
00095 return sizeof(dods_float32);
00096 }
00097
00098 bool
00099 Float32::serialize(const string &dataset, ConstraintEvaluator &eval, DDS &dds,
00100 XDR *sink, bool ce_eval)
00101 {
00102 dds.timeout_on();
00103
00104 if (!read_p())
00105 read(dataset);
00106
00107 #if EVAL
00108 if (ce_eval && !eval.eval_selection(dds, dataset))
00109 return true;
00110 #endif
00111
00112 dds.timeout_off();
00113
00114 if (!xdr_float(sink, &_buf))
00115 throw Error("Network I/O Error. Could not send float 32 data.\nThis may be due to a bug in libdap, on the server or a\nproblem with the network connection.");
00116
00117 return true;
00118 }
00119
00120 bool
00121 Float32::deserialize(XDR *source, DDS *, bool)
00122 {
00123 if (!xdr_float(source, &_buf))
00124 throw Error("Network I/O Error. Could not read float 32 data. This may be due to a\nbug in libdap or a problem with the network connection.");
00125
00126 return false;
00127 }
00128
00129 unsigned int
00130 Float32::val2buf(void *val, bool)
00131 {
00132
00133
00134
00135
00136
00137 if (!val)
00138 throw InternalErr(__FILE__, __LINE__,
00139 "The incoming pointer does not contain any data.");
00140
00141 _buf = *(dods_float32 *)val;
00142
00143 return width();
00144 }
00145
00146 unsigned int
00147 Float32::buf2val(void **val)
00148 {
00149
00150
00151 if (!val)
00152 throw InternalErr(__FILE__, __LINE__, "NULL pointer.");
00153
00154 if (!*val)
00155 *val = new dods_float32;
00156
00157 *(dods_float32 *)*val = _buf;
00158
00159 return width();
00160 }
00161
00162 bool
00163 Float32::set_value(dods_float32 f)
00164 {
00165 _buf = f;
00166 set_read_p(true);
00167
00168 return true;
00169 }
00170
00176 dods_float32
00177 Float32::value() const
00178 {
00179 return _buf;
00180 }
00181
00182 void
00183 Float32::print_val(FILE *out, string space, bool print_decl_p)
00184 {
00185
00186
00187
00188 if (print_decl_p) {
00189 print_decl(out, space, false);
00190 fprintf(out, " = %.6g;\n", _buf) ;
00191 }
00192 else
00193 fprintf(out, "%.6g", _buf) ;
00194 }
00195
00196 bool
00197 Float32::ops(BaseType *b, int op, const string &dataset)
00198 {
00199
00200 if (!read_p() && !read(dataset)) {
00201
00202
00203
00204
00205 throw InternalErr(__FILE__, __LINE__, "This value not read!");
00206 }
00207
00208
00209 if (!b->read_p() && !b->read(dataset)) {
00210 throw InternalErr(__FILE__, __LINE__, "This value not read!");
00211 }
00212
00213 switch (b->type()) {
00214 case dods_byte_c:
00215 return rops<dods_float32, dods_byte, Cmp<dods_float32, dods_byte> >
00216 (_buf, dynamic_cast<Byte *>(b)->_buf, op);
00217 case dods_int16_c:
00218 return rops<dods_float32, dods_int16, Cmp<dods_float32, dods_int16> >
00219 (_buf, dynamic_cast<Int16 *>(b)->_buf, op);
00220 case dods_uint16_c:
00221 return rops<dods_float32, dods_uint16, Cmp<dods_float32, dods_uint16> >
00222 (_buf, dynamic_cast<UInt16 *>(b)->_buf, op);
00223 case dods_int32_c:
00224 return rops<dods_float32, dods_int32, Cmp<dods_float32, dods_int32> >
00225 (_buf, dynamic_cast<Int32 *>(b)->_buf, op);
00226 case dods_uint32_c:
00227 return rops<dods_float32, dods_uint32, Cmp<dods_float32, dods_uint32> >
00228 (_buf, dynamic_cast<UInt32 *>(b)->_buf, op);
00229 case dods_float32_c:
00230 return rops<dods_float32, dods_float32, Cmp<dods_float32, dods_float32> >
00231 (_buf, dynamic_cast<Float32 *>(b)->_buf, op);
00232 case dods_float64_c:
00233 return rops<dods_float32, dods_float64, Cmp<dods_float32, dods_float64> >
00234 (_buf, dynamic_cast<Float64 *>(b)->_buf, op);
00235 default:
00236 return false;
00237 }
00238 }
00239
00248 void
00249 Float32::dump(ostream &strm) const
00250 {
00251 strm << DapIndent::LMarg << "Float32::dump - (" << (void *)this << ")"
00252 << endl ;
00253 DapIndent::Indent() ;
00254 BaseType::dump(strm) ;
00255 strm << DapIndent::LMarg << "value: " << _buf << endl ;
00256 DapIndent::UnIndent() ;
00257 }
00258