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