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