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: UInt32.cc 17002 2007-08-27 19:16:51Z pwest $"
00041 };
00042
00043 #include <stdlib.h>
00044
00045 #include "UInt32.h"
00046 #include "DDS.h"
00047 #include "util.h"
00048 #include "parser.h"
00049
00050 #include "Operators.h"
00051 #include "dods-limits.h"
00052 #include "debug.h"
00053 #include "InternalErr.h"
00054
00055
00056 using std::cerr;
00057 using std::endl;
00058
00059 UInt32::UInt32(const string &n)
00060 : BaseType(n, dods_uint32_c)
00061 {}
00062
00063 UInt32::UInt32(const UInt32 ©_from) : BaseType(copy_from)
00064 {
00065 _buf = copy_from._buf;
00066 }
00067
00068 BaseType *
00069 UInt32::ptr_duplicate()
00070 {
00071 return new UInt32(*this);
00072 }
00073
00074 UInt32 &
00075 UInt32::operator=(const UInt32 &rhs)
00076 {
00077 if (this == &rhs)
00078 return *this;
00079
00080 dynamic_cast<BaseType &>(*this) = rhs;
00081
00082 _buf = rhs._buf;
00083
00084 return *this;
00085 }
00086
00087 unsigned int
00088 UInt32::width()
00089 {
00090 return sizeof(dods_uint32);
00091 }
00092
00093 bool
00094 UInt32::serialize(const string &dataset, ConstraintEvaluator &eval, DDS &dds,
00095 Marshaller &m, bool ce_eval)
00096 {
00097 dds.timeout_on();
00098
00099 if (!read_p())
00100 read(dataset);
00101
00102 #if EVAL
00103 if (ce_eval && !eval.eval_selection(dds, dataset))
00104 return true;
00105 #endif
00106
00107 dds.timeout_off();
00108
00109 m.put_uint32( _buf ) ;
00110
00111 return true;
00112 }
00113
00114 bool
00115 UInt32::deserialize(UnMarshaller &um, DDS *, bool)
00116 {
00117 um.get_uint32( _buf ) ;
00118
00119 return false;
00120 }
00121
00122 unsigned int
00123 UInt32::val2buf(void *val, bool)
00124 {
00125
00126
00127
00128
00129
00130 if (!val)
00131 throw InternalErr(__FILE__, __LINE__,
00132 "The incoming pointer does not contain any data.");
00133
00134 _buf = *(dods_uint32 *)val;
00135
00136 return width();
00137 }
00138
00139 unsigned int
00140 UInt32::buf2val(void **val)
00141 {
00142
00143
00144 if (!val)
00145 throw InternalErr(__FILE__, __LINE__, "NULL pointer.");
00146
00147 if (!*val)
00148 *val = new dods_uint32;
00149
00150 *(dods_uint32 *)*val = _buf;
00151
00152 return width();
00153 }
00154
00155 dods_uint32
00156 UInt32::value() const
00157 {
00158 return _buf;
00159 }
00160
00161 bool
00162 UInt32::set_value(dods_uint32 i)
00163 {
00164 _buf = i;
00165 set_read_p(true);
00166
00167 return true;
00168 }
00169
00170 void
00171 UInt32::print_val(FILE *out, string space, bool print_decl_p)
00172 {
00173 if (print_decl_p) {
00174 print_decl(out, space, false);
00175 fprintf(out, " = %u;\n", (unsigned int)_buf) ;
00176 }
00177 else
00178 fprintf(out, "%u", (unsigned int)_buf) ;
00179 }
00180
00181 void
00182 UInt32::print_val(ostream &out, string space, bool print_decl_p)
00183 {
00184 if (print_decl_p) {
00185 print_decl(out, space, false);
00186 out << " = " << (unsigned int)_buf << ";\n" ;
00187 }
00188 else
00189 out << (unsigned int)_buf ;
00190 }
00191
00192 bool
00193 UInt32::ops(BaseType *b, int op, const string &dataset)
00194 {
00195
00196 if (!read_p() && !read(dataset)) {
00197
00198
00199
00200
00201
00202 throw InternalErr(__FILE__, __LINE__, "This value was not read!");
00203 }
00204
00205
00206 if (!b->read_p() && !b->read(dataset)) {
00207
00208
00209
00210
00211
00212 throw InternalErr(__FILE__, __LINE__, "This value was not read!");
00213 }
00214
00215 switch (b->type()) {
00216 case dods_byte_c:
00217 return rops<dods_uint32, dods_byte, Cmp<dods_uint32, dods_byte> >
00218 (_buf, dynamic_cast<Byte *>(b)->_buf, op);
00219 case dods_int16_c:
00220 return rops<dods_uint32, dods_int16, USCmp<dods_uint32, dods_int16> >
00221 (_buf, dynamic_cast<Int16 *>(b)->_buf, op);
00222 case dods_uint16_c:
00223 return rops<dods_uint32, dods_uint16, Cmp<dods_uint32, dods_uint16> >
00224 (_buf, dynamic_cast<UInt16 *>(b)->_buf, op);
00225 case dods_int32_c:
00226 return rops<dods_uint32, dods_int32, USCmp<dods_uint32, dods_int32> >
00227 (_buf, dynamic_cast<Int32 *>(b)->_buf, op);
00228 case dods_uint32_c:
00229 return rops<dods_uint32, dods_uint32, Cmp<dods_uint32, dods_uint32> >
00230 (_buf, dynamic_cast<UInt32 *>(b)->_buf, op);
00231 case dods_float32_c:
00232 return rops<dods_uint32, dods_float32, Cmp<dods_uint32, dods_float32> >
00233 (_buf, dynamic_cast<Float32 *>(b)->_buf, op);
00234 case dods_float64_c:
00235 return rops<dods_uint32, dods_float64, Cmp<dods_uint32, dods_float64> >
00236 (_buf, dynamic_cast<Float64 *>(b)->_buf, op);
00237 default:
00238 return false;
00239 }
00240 }
00241
00250 void
00251 UInt32::dump(ostream &strm) const
00252 {
00253 strm << DapIndent::LMarg << "UInt32::dump - ("
00254 << (void *)this << ")" << endl ;
00255 DapIndent::Indent() ;
00256 BaseType::dump(strm) ;
00257 strm << DapIndent::LMarg << "value: " << _buf << endl ;
00258 DapIndent::UnIndent() ;
00259 }
00260