UInt16.cc

Go to the documentation of this file.
00001 
00002 // -*- mode: c++; c-basic-offset:4 -*-
00003 
00004 // This file is part of libdap, A C++ implementation of the OPeNDAP Data
00005 // Access Protocol.
00006 
00007 // Copyright (c) 2002,2003 OPeNDAP, Inc.
00008 // Author: James Gallagher <jgallagher@opendap.org>
00009 //
00010 // This library is free software; you can redistribute it and/or
00011 // modify it under the terms of the GNU Lesser General Public
00012 // License as published by the Free Software Foundation; either
00013 // version 2.1 of the License, or (at your option) any later version.
00014 //
00015 // This library is distributed in the hope that it will be useful,
00016 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00018 // Lesser General Public License for more details.
00019 //
00020 // You should have received a copy of the GNU Lesser General Public
00021 // License along with this library; if not, write to the Free Software
00022 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00023 //
00024 // You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
00025 
00026 // (c) COPYRIGHT URI/MIT 1999
00027 // Please read the full copyright statement in the file COPYRIGHT_URI.
00028 //
00029 // Authors:
00030 //      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>
00031 
00032 // Implementation for Int32.
00033 //
00034 // jhrg 9/7/94
00035 
00036 
00037 #include "config.h"
00038 
00039 static char rcsid[] not_used =
00040     {"$Id: UInt16.cc 20518 2009-03-05 23:39:46Z jimg $"
00041     };
00042 
00043 #include "UInt16.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 UInt16::UInt16(const string &n)
00062         : BaseType(n, dods_uint16_c)
00063 {}
00064 
00072 UInt16::UInt16(const string &n, const string &d)
00073         : BaseType(n, d, dods_uint16_c)
00074 {}
00075 
00076 UInt16::UInt16(const UInt16 &copy_from) : BaseType(copy_from)
00077 {
00078     _buf = copy_from._buf;
00079 }
00080 
00081 BaseType *
00082 UInt16::ptr_duplicate()
00083 {
00084     return new UInt16(*this);
00085 }
00086 
00087 UInt16 &
00088 UInt16::operator=(const UInt16 &rhs)
00089 {
00090     if (this == &rhs)
00091         return *this;
00092 
00093     dynamic_cast<BaseType &>(*this) = rhs;
00094 
00095     _buf = rhs._buf;
00096 
00097     return *this;
00098 }
00099 
00100 unsigned int
00101 UInt16::width()
00102 {
00103     return sizeof(dods_uint16);
00104 }
00105 
00106 bool
00107 UInt16::serialize(ConstraintEvaluator &eval, DDS &dds,
00108                   Marshaller &m, bool ce_eval)
00109 {
00110     dds.timeout_on();
00111 
00112     if (!read_p())
00113         read();  // read() throws Error and InternalErr
00114 
00115 #if EVAL
00116     if (ce_eval && !eval.eval_selection(dds, dataset()))
00117         return true;
00118 #endif
00119 
00120     dds.timeout_off();
00121 
00122     m.put_uint16( _buf ) ;
00123 
00124     return true;
00125 }
00126 
00127 bool
00128 UInt16::deserialize(UnMarshaller &um, DDS *, bool)
00129 {
00130     um.get_uint16( _buf ) ;
00131 
00132     return false;
00133 }
00134 
00135 unsigned int
00136 UInt16::val2buf(void *val, bool)
00137 {
00138     // Jose Garcia
00139     // This method is public therefore and I believe it has being designed
00140     // to be use by read which must be implemented on the surrogated library,
00141     // thus if the pointer val is NULL, is an Internal Error.
00142     if (!val)
00143         throw InternalErr(__FILE__, __LINE__,
00144                           "The incoming pointer does not contain any data.");
00145 
00146     _buf = *(dods_uint16 *)val;
00147 
00148     return width();
00149 }
00150 
00151 unsigned int
00152 UInt16::buf2val(void **val)
00153 {
00154     // Jose Garcia
00155     // The same comment justifying throwing an Error in val2buf applies here.
00156     if (!val)
00157         throw InternalErr(__FILE__, __LINE__, "NULL pointer.");
00158 
00159     if (!*val)
00160         *val = new dods_uint16;
00161 
00162     *(dods_uint16 *)*val = _buf;
00163 
00164     return width();
00165 }
00166 
00167 dods_uint16
00168 UInt16::value() const
00169 {
00170     return _buf;
00171 }
00172 
00173 bool
00174 UInt16::set_value(dods_uint16 i)
00175 {
00176     _buf = i;
00177     set_read_p(true);
00178 
00179     return true;
00180 }
00181 //#if FILE_METHODS
00182 void
00183 UInt16::print_val(FILE *out, string space, bool print_decl_p)
00184 {
00185     if (print_decl_p) {
00186         print_decl(out, space, false);
00187         fprintf(out, " = %u;\n", (unsigned int)_buf) ;
00188     }
00189     else
00190         fprintf(out, "%u", (unsigned int)_buf) ;
00191 }
00192 //#endif
00193 void
00194 UInt16::print_val(ostream &out, string space, bool print_decl_p)
00195 {
00196     if (print_decl_p) {
00197         print_decl(out, space, false);
00198         out << " = " << (unsigned int)_buf << ";\n" ;
00199     }
00200     else
00201         out << (unsigned int)_buf ;
00202 }
00203 
00204 bool
00205 UInt16::ops(BaseType *b, int op)
00206 {
00207     // Extract the Byte arg's value.
00208     if (!read_p() && !read()) {
00209         // Jose Garcia
00210         // Since the read method is virtual and implemented outside
00211         // libdap++ if we cannot read the data that is the problem
00212         // of the user or of whoever wrote the surrogate library
00213         // implemeting read therefore it is an internal error.
00214         throw InternalErr(__FILE__, __LINE__, "This value was not read!");
00215     }
00216 
00217     // Extract the second arg's value.
00218     if (!b || !b->read_p() && !b->read()) {
00219         // Jose Garcia
00220         // Since the read method is virtual and implemented outside
00221         // libdap++ if we cannot read the data that is the problem
00222         // of the user or of whoever wrote the surrogate library
00223         // implemeting read therefore it is an internal error.
00224         throw InternalErr(__FILE__, __LINE__, "This value was not read!");
00225     }
00226 
00227     switch (b->type()) {
00228     case dods_byte_c:
00229         return rops<dods_uint16, dods_byte, Cmp<dods_uint16, dods_byte> >
00230                (_buf, dynamic_cast<Byte *>(b)->_buf, op);
00231     case dods_int16_c:
00232         return rops<dods_uint16, dods_int16, USCmp<dods_uint16, dods_int16> >
00233                (_buf, dynamic_cast<Int16 *>(b)->_buf, op);
00234     case dods_uint16_c:
00235         return rops<dods_uint16, dods_uint16, Cmp<dods_uint16, dods_uint16> >
00236                (_buf, dynamic_cast<UInt16 *>(b)->_buf, op);
00237     case dods_int32_c:
00238         return rops<dods_uint16, dods_int32, USCmp<dods_uint16, dods_int32> >
00239                (_buf, dynamic_cast<Int32 *>(b)->_buf, op);
00240     case dods_uint32_c:
00241         return rops<dods_uint16, dods_uint32, Cmp<dods_uint16, dods_uint32> >
00242                (_buf, dynamic_cast<UInt32 *>(b)->_buf, op);
00243     case dods_float32_c:
00244         return rops<dods_uint16, dods_float32, Cmp<dods_uint16, dods_float32> >
00245                (_buf, dynamic_cast<Float32 *>(b)->_buf, op);
00246     case dods_float64_c:
00247         return rops<dods_uint16, dods_float64, Cmp<dods_uint16, dods_float64> >
00248                (_buf, dynamic_cast<Float64 *>(b)->_buf, op);
00249     default:
00250         return false;
00251     }
00252 }
00253 
00262 void
00263 UInt16::dump(ostream &strm) const
00264 {
00265     strm << DapIndent::LMarg << "UInt16::dump - ("
00266     << (void *)this << ")" << endl ;
00267     DapIndent::Indent() ;
00268     BaseType::dump(strm) ;
00269     strm << DapIndent::LMarg << "value: " << _buf << endl ;
00270     DapIndent::UnIndent() ;
00271 }
00272 
00273 } // namespace libdap
00274 

Generated on Wed Apr 15 19:20:23 2009 for libdap++ by  doxygen 1.4.7