44 #include "D4StreamMarshaller.h"
45 #include "D4StreamUnMarshaller.h"
50 #include "Operators.h"
51 #include "dods-limits.h"
53 #include "InternalErr.h"
54 #include "DapIndent.h"
88 d_buf = copy_from.d_buf;
94 return new Int8(*
this);
98 Int8::operator=(
const Int8 &rhs)
103 static_cast<BaseType &
>(*this) = rhs;
113 return sizeof(dods_int8);
119 checksum.
AddData(reinterpret_cast<uint8_t*>(&d_buf),
sizeof(d_buf));
136 m.put_int8( d_buf ) ;
142 um.get_int8( d_buf ) ;
152 Int8::set_value(dods_int8 i)
160 void Int8::print_val(ostream &out,
string space,
bool print_decl_p)
164 out <<
" = " << (int)d_buf <<
";\n";
175 throw InternalErr(__FILE__, __LINE__,
"This value not read!");
179 throw InternalErr(__FILE__, __LINE__,
"This value not read!");
191 return Cmp<dods_int8, dods_int8>(op, d_buf,
static_cast<Int8*
>(b)->value());
193 return SUCmp<dods_int8, dods_byte>(op, d_buf,
static_cast<Byte*
>(b)->value());
195 return Cmp<dods_int8, dods_int16>(op, d_buf,
static_cast<Int16*
>(b)->value());
197 return SUCmp<dods_int8, dods_uint16>(op, d_buf,
static_cast<UInt16*
>(b)->value());
199 return Cmp<dods_int8, dods_int32>(op, d_buf,
static_cast<Int32*
>(b)->value());
201 return SUCmp<dods_int8, dods_uint32>(op, d_buf,
static_cast<UInt32*
>(b)->value());
203 return Cmp<dods_int8, dods_int64>(op, d_buf,
static_cast<Int64*
>(b)->value());
205 return SUCmp<dods_int8, dods_uint64>(op, d_buf,
static_cast<UInt64*
>(b)->value());
207 return Cmp<dods_int8, dods_float32>(op, d_buf,
static_cast<Float32*
>(b)->value());
209 return Cmp<dods_int8, dods_float64>(op, d_buf,
static_cast<Float64*
>(b)->value());
212 throw Error(malformed_expr,
"Relational operators can only compare compatible types (number, string).");
214 throw Error(malformed_expr,
"Relational operators only work with scalar types.");
231 std::vector<BaseType *> *
237 oss << __func__ <<
"() - Something Bad Happened. This transform should produce only ";
238 oss <<
" a single BaseType yet it produced " << vec->size();
239 throw Error(internal_error,oss.str());
241 (*vec)[0]->set_type(dods_byte_c);
256 strm << DapIndent::LMarg <<
"Int8::dump - ("
257 << (
void *)
this <<
")" << endl ;
258 DapIndent::Indent() ;
260 strm << DapIndent::LMarg <<
"value: " << d_buf << endl ;
261 DapIndent::UnIndent() ;
virtual bool ops(BaseType *b, int op)
Evaluate relational operators.
virtual bool read()
Read data into a local buffer.
Holds an 8-bit signed integer value.
Holds a64-bit signed integer.
virtual bool read_p()
Has this variable been read?
virtual void print_decl(FILE *out, string space=" ", bool print_semi=true, bool constraint_info=false, bool constrained=false)
Print an ASCII representation of the variable structure.
virtual std::vector< BaseType * > * transform_to_dap2(AttrTable *parent_attr_table)
DAP4 to DAP2 transform.
Contains the attributes for a dataset.
Read data from the stream made by D4StreamMarshaller.
Holds an unsigned 16-bit integer.
virtual unsigned int width(bool constrained=false) const
How many bytes does this variable use Return the number of bytes of storage this variable uses...
virtual Type type() const
Returns the type of the class instance.
virtual void compute_checksum(Crc32 &checksum)
include the data for this variable in the checksum DAP4 includes a checksum with every data response...
Holds a 32-bit floating point value.
virtual BaseType * ptr_duplicate()
A class for software fault reporting.
Marshaller that knows how to marshal/serialize dap data objects to a C++ iostream using DAP4's receiv...
Holds a 16-bit signed integer value.
virtual void dump(ostream &strm) const
dumps information about this object
virtual void set_read_p(bool state)
Sets the value of the read_p property.
Holds a 64-bit unsigned integer.
void AddData(const uint8_t *pData, const uint32_t length)
virtual std::vector< BaseType * > * transform_to_dap2(AttrTable *parent_attr_table)
DAP4 to DAP2 transform.
virtual void deserialize(D4StreamUnMarshaller &um, DMR &dmr)
The basic data type for the DODS DAP types.
Holds a 64-bit (double precision) floating point value.
virtual bool d4_ops(BaseType *b, int op)
A class for error processing.
Holds a 32-bit unsigned integer.
virtual void dump(ostream &strm) const
dumps information about this object
virtual void serialize(D4StreamMarshaller &m, DMR &dmr, bool filter=false)
Serialize an Int8.
Holds a 32-bit signed integer.