41 #if USE_XDR_FOR_IEEE754_ENCODING
57 inline uint8_t* WriteVarint64ToArrayInline(uint64_t value, uint8_t* target) {
60 uint32_t part0 =
static_cast<uint32_t
>(value );
61 uint32_t part1 =
static_cast<uint32_t
>(value >> 28);
62 uint32_t part2 =
static_cast<uint32_t
>(value >> 56);
75 if (part0 < (1 << 14)) {
76 if (part0 < (1 << 7)) {
82 if (part0 < (1 << 21)) {
89 if (part1 < (1 << 14)) {
90 if (part1 < (1 << 7)) {
96 if (part1 < (1 << 21)) {
104 if (part2 < (1 << 7)) {
105 size = 9;
goto size9;
107 size = 10;
goto size10;
113 size10: target[9] =
static_cast<uint8_t
>((part2 >> 7) | 0x80);
114 size9 : target[8] =
static_cast<uint8_t
>((part2 ) | 0x80);
115 size8 : target[7] =
static_cast<uint8_t
>((part1 >> 21) | 0x80);
116 size7 : target[6] =
static_cast<uint8_t
>((part1 >> 14) | 0x80);
117 size6 : target[5] =
static_cast<uint8_t
>((part1 >> 7) | 0x80);
118 size5 : target[4] =
static_cast<uint8_t
>((part1 ) | 0x80);
119 size4 : target[3] =
static_cast<uint8_t
>((part0 >> 21) | 0x80);
120 size3 : target[2] =
static_cast<uint8_t
>((part0 >> 14) | 0x80);
121 size2 : target[1] =
static_cast<uint8_t
>((part0 >> 7) | 0x80);
122 size1 : target[0] =
static_cast<uint8_t
>((part0 ) | 0x80);
124 target[size-1] &= 0x7F;
125 return target + size;
129 #if USE_XDR_FOR_IEEE754_ENCODING
135 void D4StreamMarshaller::m_serialize_reals(
char *val,
unsigned int num,
int width,
Type type)
139 vector<char> buf(size);
141 xdrmem_create(&xdr, &buf[0], size, XDR_ENCODE);
143 if(!xdr_array(&xdr, &val, (
unsigned int *)&num, size, width, XDRUtils::xdr_coder(type)))
144 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float64 array");
146 if (xdr_getpos(&xdr) != size)
147 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float64 array");
168 d_out.write(&buf[0], size);
185 D4StreamMarshaller::D4StreamMarshaller(ostream &out,
bool write_data) :
186 d_out(out), d_write_data(write_data)
188 assert(
sizeof(std::streamsize) >=
sizeof(int64_t));
190 #if USE_XDR_FOR_IEEE754_ENCODING
194 xdrmem_create(&d_scalar_sink, d_ieee754_buf,
sizeof(
dods_float64), XDR_ENCODE);
199 out.exceptions(ostream::failbit | ostream::badbit);
204 #if USE_XDR_FOR_IEEE754_ENCODING
205 xdr_destroy(&d_scalar_sink);
229 oss.setf(ios::hex, ios::basefield);
230 oss << setfill(
'0') << setw(8) << d_checksum.
GetCrc32();
249 d_checksum.
AddData(reinterpret_cast<const uint8_t*>(data), len);
257 DBG( std::cerr <<
"put_byte: " << val << std::endl );
259 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_byte));
268 DBG( std::cerr <<
"put_int8: " << val << std::endl );
270 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_int8));
279 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_int16));
287 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_int32));
295 d_out.write(reinterpret_cast<const char*>(&val),
sizeof(
dods_int64));
300 #if !USE_XDR_FOR_IEEE754_ENCODING
301 assert(std::numeric_limits<float>::is_iec559);
306 d_out.write(reinterpret_cast<const char*>(&val),
sizeof(
dods_float32));
315 if (std::numeric_limits<float>::is_iec559 ) {
316 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_float32));
319 if (!xdr_setpos(&d_scalar_sink, 0))
320 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float32 variable");
322 if (!xdr_float(&d_scalar_sink, &val))
323 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float32 variable");
326 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float32 variable");
343 #if !USE_XDR_FOR_IEEE754_ENCODING
344 assert(std::numeric_limits<double>::is_iec559);
349 d_out.write(reinterpret_cast<const char*>(&val),
sizeof(
dods_float64));
354 if (std::numeric_limits<double>::is_iec559)
355 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_float64));
357 if (!xdr_setpos(&d_scalar_sink, 0))
358 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float64 variable");
360 if (!xdr_double(&d_scalar_sink, &val))
361 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float64 variable");
364 throw InternalErr(__FILE__, __LINE__,
"Error serializing a Float64 variable");
384 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_uint16));
392 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_uint32));
400 d_out.write(reinterpret_cast<char*>(&val),
sizeof(
dods_uint64));
413 d_out.write(reinterpret_cast<const char*>(&count),
sizeof(int64_t));
421 int64_t len = val.length();
423 d_out.write(reinterpret_cast<const char*>(&len),
sizeof(int64_t));
424 d_out.write(val.data(), val.length());
438 d_out.write(reinterpret_cast<const char*>(&len),
sizeof(int64_t));
439 d_out.write(val, len);
453 d_out.write(val, num_bytes);
459 assert(num_elem >= 0);
460 assert(elem_size > 0);
466 assert(!
"Don't call this method for bytes, use put_vector(val, bytes) instead");
471 assert(!(num_elem & 0x4000000000000000));
472 bytes = num_elem << 1;
475 assert(!(num_elem & 0x6000000000000000));
476 bytes = num_elem << 2;
479 assert(!(num_elem & 0x7000000000000000));
480 bytes = num_elem << 3;
483 bytes = num_elem * elem_size;
490 d_out.write(val, bytes);
504 #if !USE_XDR_FOR_IEEE754_ENCODING
506 assert(std::numeric_limits<float>::is_iec559);
508 assert(num_elem >= 0);
513 assert(!(num_elem & 0xe000000000000000));
515 num_elem = num_elem << 2;
520 d_out.write(val, num_elem);
524 assert(num_elem >= 0);
529 assert(!(num_elem & 0xe000000000000000));
531 int64_t bytes = num_elem << 2;
536 if (!std::numeric_limits<float>::is_iec559) {
538 m_serialize_reals(val, num_elem, 4, type);
541 d_out.write(val, bytes);
557 #if !USE_XDR_FOR_IEEE754_ENCODING
559 assert(std::numeric_limits<double>::is_iec559);
561 assert(num_elem >= 0);
563 assert(!(num_elem & 0xf000000000000000));
565 num_elem = num_elem << 3;
570 d_out.write(val, num_elem);
573 assert(num_elem >= 0);
578 assert(!(num_elem & 0xe000000000000000));
580 int64_t bytes = num_elem << 3;
585 if (!std::numeric_limits<double>::is_iec559) {
587 m_serialize_reals(val, num_elem, 8, type);
590 d_out.write(val, bytes);
599 strm <<
DapIndent::LMarg <<
"D4StreamMarshaller::dump - (" << (
void *)
this <<
")" << endl;
virtual void put_opaque_dap4(const char *val, int64_t len)
virtual void put_float64(dods_float64 val)
checksum GetCrc32() const
virtual void put_int16(dods_int16 val)
virtual void put_count(int64_t count)
virtual void put_byte(dods_byte val)
virtual void dump(std::ostream &strm) const
dump the contents of this object to the specified ostream
virtual void put_vector_float32(char *val, int64_t num_elem)
Write a fixed size vector.
Type
Identifies the data type.
virtual void put_uint16(dods_uint16 val)
A class for software fault reporting.
virtual void put_uint32(dods_uint32 val)
virtual void put_int8(dods_int8 val)
void AddData(const uint8_t *pData, const uint32_t length)
static ostream & LMarg(ostream &strm)
virtual void checksum_update(const void *data, unsigned long len)
virtual void put_uint64(dods_uint64 val)
virtual void put_vector(char *val, int64_t num_bytes)
Write a fixed size vector.
virtual string get_checksum()
virtual void put_vector_float64(char *val, int64_t num_elem)
Write a fixed size vector of float64s.
virtual void put_checksum()
Write the checksum Write the checksum for the data sent since the last call to reset_checksum() to th...
bool is_host_big_endian()
Does this host use big-endian byte order?
virtual void put_float32(dods_float32 val)
virtual void put_int32(dods_int32 val)
virtual void reset_checksum()
virtual void put_str(const string &val)
virtual void put_int64(dods_int64 val)
virtual void put_url(const string &val)
virtual ~D4StreamMarshaller()