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