D4StreamMarshaller.cc

// D4StreamMarshaller.cc
 
// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2012 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#include "config.h"
 
#include <byteswap.h>
#include <cassert>
#include <cstring>
 
#include <iostream>
#include <sstream>
#include <iomanip>
#include <limits>
 
//#define DODS_DEBUG 1
 
#ifdef HAVE_PTHREAD_H
#include <pthread.h>
#endif
 
#include "D4StreamMarshaller.h"
#ifdef USE_POSIX_THREADS
#include "MarshallerThread.h"
#endif
 
#if USE_XDR_FOR_IEEE754_ENCODING
#include "XDRUtils.h"
#include "util.h"
#endif
 
#include "debug.h"
 
using namespace std;
 
namespace libdap {
 
#if 0
// We decided to use int64_t to represent sizes of both arrays and strings,
// So this code is not used. jhrg 10/4/13
 
// From the Google protobuf library
inline uint8_t* WriteVarint64ToArrayInline(uint64_t value, uint8_t* target) {
  // Splitting into 32-bit pieces gives better performance on 32-bit
  // processors.
  uint32_t part0 = static_cast<uint32_t>(value      );
  uint32_t part1 = static_cast<uint32_t>(value >> 28);
  uint32_t part2 = static_cast<uint32_t>(value >> 56);
 
  int size;
 
  // Here we can't really optimize for small numbers, since the value is
  // split into three parts.  Checking for numbers < 128, for instance,
  // would require three comparisons, since you'd have to make sure part1
  // and part2 are zero.  However, if the caller is using 64-bit integers,
  // it is likely that they expect the numbers to often be very large, so
  // we probably don't want to optimize for small numbers anyway.  Thus,
  // we end up with a hard coded binary search tree...
  if (part2 == 0) {
    if (part1 == 0) {
      if (part0 < (1 << 14)) {
        if (part0 < (1 << 7)) {
          size = 1; goto size1;
        } else {
          size = 2; goto size2;
        }
      } else {
        if (part0 < (1 << 21)) {
          size = 3; goto size3;
        } else {
          size = 4; goto size4;
        }
      }
    } else {
      if (part1 < (1 << 14)) {
        if (part1 < (1 << 7)) {
          size = 5; goto size5;
        } else {
          size = 6; goto size6;
        }
      } else {
        if (part1 < (1 << 21)) {
          size = 7; goto size7;
        } else {
          size = 8; goto size8;
        }
      }
    }
  } else {
    if (part2 < (1 << 7)) {
      size = 9; goto size9;
    } else {
      size = 10; goto size10;
    }
  }
 
  // GOOGLE_LOG(FATAL) << "Can't get here.";
 
  size10: target[9] = static_cast<uint8_t>((part2 >>  7) | 0x80);
  size9 : target[8] = static_cast<uint8_t>((part2      ) | 0x80);
  size8 : target[7] = static_cast<uint8_t>((part1 >> 21) | 0x80);
  size7 : target[6] = static_cast<uint8_t>((part1 >> 14) | 0x80);
  size6 : target[5] = static_cast<uint8_t>((part1 >>  7) | 0x80);
  size5 : target[4] = static_cast<uint8_t>((part1      ) | 0x80);
  size4 : target[3] = static_cast<uint8_t>((part0 >> 21) | 0x80);
  size3 : target[2] = static_cast<uint8_t>((part0 >> 14) | 0x80);
  size2 : target[1] = static_cast<uint8_t>((part0 >>  7) | 0x80);
  size1 : target[0] = static_cast<uint8_t>((part0      ) | 0x80);
 
  target[size-1] &= 0x7F;
  return target + size;
}
#endif
 
#if USE_XDR_FOR_IEEE754_ENCODING
void D4StreamMarshaller::m_serialize_reals(char *val, unsigned int num, int width, Type type)
{
    dods_uint64 size = num * width;
 
    char *buf = new char[size];
    XDR xdr;
    xdrmem_create(&xdr, &buf[0], size, XDR_ENCODE);
    try {
        if(!xdr_array(&xdr, &val, (unsigned int *)&num, size, width, XDRUtils::xdr_coder(type)))
            throw InternalErr(__FILE__, __LINE__, "Error serializing a Float64 array");
 
        if (xdr_getpos(&xdr) != size)
            throw InternalErr(__FILE__, __LINE__, "Error serializing a Float64 array");
 
        // If this is a little-endian host, twiddle the bytes
        static bool twiddle_bytes = !is_host_big_endian();
        if (twiddle_bytes) {
            if (width == 4) {
                dods_float32 *lbuf = reinterpret_cast<dods_float32*>(&buf[0]);
                while (num--) {
                    dods_int32 *i = reinterpret_cast<dods_int32*>(lbuf++);
                    *i = bswap_32(*i);
                }
            }
            else { // width == 8
                dods_float64 *lbuf = reinterpret_cast<dods_float64*>(&buf[0]);
                while (num--) {
                    dods_int64 *i = reinterpret_cast<dods_int64*>(lbuf++);
                    *i = bswap_64(*i);
                }
            }
        }
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, size);
 
        // The child thread will delete buf when it's done
        xdr_destroy(&xdr);
#else
        d_out.write(&buf[0], size);
        xdr_destroy(&xdr);
        delete [] buf;
#endif
    }
    catch (...) {
        xdr_destroy(&xdr);
        delete [] buf;
 
        throw;
    }
}
#endif
 
D4StreamMarshaller::D4StreamMarshaller(ostream &out, bool write_data) :
        d_out(out), d_write_data(write_data), tm(0)
{
        assert(sizeof(std::streamsize) >= sizeof(int64_t));
 
#if USE_XDR_FOR_IEEE754_ENCODING
    // XDR is used if the call std::numeric_limits<double>::is_iec559()
    // returns false indicating that the compiler is not using IEEE 754.
    // If it is, we just write out the bytes.
    xdrmem_create(&d_scalar_sink, d_ieee754_buf, sizeof(dods_float64), XDR_ENCODE);
#endif
 
#ifdef USE_POSIX_THREADS
    tm = new MarshallerThread;
#endif
 
    // This will cause exceptions to be thrown on i/o errors. The exception
    // will be ostream::failure
    out.exceptions(ostream::failbit | ostream::badbit);
}
 
D4StreamMarshaller::~D4StreamMarshaller()
{
#if USE_XDR_FOR_IEEE754_ENCODING
    xdr_destroy(&d_scalar_sink);
#endif
 
    delete tm;
}
 
void D4StreamMarshaller::reset_checksum()
{
    d_checksum.Reset();
}
 
string D4StreamMarshaller::get_checksum()
{
    ostringstream oss;
    oss.setf(ios::hex, ios::basefield);
    oss << setfill('0') << setw(8) << d_checksum.GetCrc32();
 
    return oss.str();
}
 
void D4StreamMarshaller::put_checksum()
{
    Crc32::checksum chk = d_checksum.GetCrc32();
#ifdef USE_POSIX_THREADS
    Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
    d_out.write(reinterpret_cast<char*>(&chk), sizeof(Crc32::checksum));
}
 
void D4StreamMarshaller::checksum_update(const void *data, unsigned long len)
{
    d_checksum.AddData(reinterpret_cast<const uint8_t*>(data), len);
}
 
void D4StreamMarshaller::put_byte(dods_byte val)
{
    checksum_update(&val, sizeof(dods_byte));
 
    if (d_write_data) {
        DBG( std::cerr << "put_byte: " << val << std::endl );
#ifdef USE_POSIX_THREADS
        // make sure that a child thread is not writing to d_out.
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_byte));
    }
}
 
void D4StreamMarshaller::put_int8(dods_int8 val)
{
    checksum_update(&val, sizeof(dods_int8));
 
    if (d_write_data) {
        DBG( std::cerr << "put_int8: " << val << std::endl );
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_int8));
    }
}
 
void D4StreamMarshaller::put_int16(dods_int16 val)
{
    checksum_update(&val, sizeof(dods_int16));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_int16));
    }
}
 
void D4StreamMarshaller::put_int32(dods_int32 val)
{
    checksum_update(&val, sizeof(dods_int32));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_int32));
    }
}
 
void D4StreamMarshaller::put_int64(dods_int64 val)
{
    checksum_update(&val, sizeof(dods_int64));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<const char*>(&val), sizeof(dods_int64));
    }
}
 
void D4StreamMarshaller::put_float32(dods_float32 val)
{
#if !USE_XDR_FOR_IEEE754_ENCODING
        assert(std::numeric_limits<float>::is_iec559);
 
    checksum_update(&val, sizeof(dods_float32));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<const char*>(&val), sizeof(dods_float32));
    }
 
#else
    // This code uses XDR to convert from a local representation to IEEE754;
    // The extra 'twiddle' operation makes the byte-order correct for this
    // host should it not be big-endian. Also note the assert() at the
    // start of the method.
 
    if (d_write_data) {
        if (std::numeric_limits<float>::is_iec559 ) {
#ifdef USE_POSIX_THREADS
            Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
            d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_float32));
        }
        else {
            if (!xdr_setpos(&d_scalar_sink, 0))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float32 variable");
 
            if (!xdr_float(&d_scalar_sink, &val))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float32 variable");
 
            if (xdr_getpos(&d_scalar_sink) != sizeof(dods_float32))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float32 variable");
 
            // If this is a little-endian host, twiddle the bytes
            static bool twiddle_bytes = !is_host_big_endian();
            if (twiddle_bytes) {
                dods_int32 *i = reinterpret_cast<dods_int32*>(&d_ieee754_buf);
                *i = bswap_32(*i);
            }
#ifdef USE_POSIX_THREADS
            Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
            d_out.write(d_ieee754_buf, sizeof(dods_float32));
        }
    }
#endif
}
 
void D4StreamMarshaller::put_float64(dods_float64 val)
{
#if !USE_XDR_FOR_IEEE754_ENCODING
        assert(std::numeric_limits<double>::is_iec559);
 
    checksum_update(&val, sizeof(dods_float64));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<const char*>(&val), sizeof(dods_float64));
    }
 
#else
    // See the comment above in put_float32()
    if (d_write_data) {
        if (std::numeric_limits<double>::is_iec559) {
#ifdef USE_POSIX_THREADS
            Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
            d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_float64));}
    }
        else {
            if (!xdr_setpos(&d_scalar_sink, 0))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float64 variable");
 
            if (!xdr_double(&d_scalar_sink, &val))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float64 variable");
 
            if (xdr_getpos(&d_scalar_sink) != sizeof(dods_float64))
                throw InternalErr(__FILE__, __LINE__, "Error serializing a Float64 variable");
 
            // If this is a little-endian host, twiddle the bytes
            static bool twiddle_bytes = !is_host_big_endian();
            if (twiddle_bytes) {
                dods_int64 *i = reinterpret_cast<dods_int64*>(&d_ieee754_buf);
                *i = bswap_64(*i);
            }
 
#ifdef USE_POSIX_THREADS
            Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
            d_out.write(d_ieee754_buf, sizeof(dods_float64));
        }
    }
#endif
}
 
void D4StreamMarshaller::put_uint16(dods_uint16 val)
{
    checksum_update(&val, sizeof(dods_uint16));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_uint16));
    }
}
 
void D4StreamMarshaller::put_uint32(dods_uint32 val)
{
    checksum_update(&val, sizeof(dods_uint32));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_uint32));
    }
}
 
void D4StreamMarshaller::put_uint64(dods_uint64 val)
{
    checksum_update(&val, sizeof(dods_uint64));
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<char*>(&val), sizeof(dods_uint64));
    }
}
 
void D4StreamMarshaller::put_count(int64_t count)
{
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<const char*>(&count), sizeof(int64_t));
}
 
void D4StreamMarshaller::put_str(const string &val)
{
    checksum_update(val.c_str(), val.length());
 
    if (d_write_data) {
        int64_t len = val.length();
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
#endif
        d_out.write(reinterpret_cast<const char*>(&len), sizeof(int64_t));
        d_out.write(val.data(), val.length());
    }
}
 
void D4StreamMarshaller::put_url(const string &val)
{
    put_str(val);
}
 
void D4StreamMarshaller::put_opaque_dap4(const char *val, int64_t len)
{
    assert(val);
    assert(len >= 0);
 
    checksum_update(val, len);
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        d_out.write(reinterpret_cast<const char*>(&len), sizeof(int64_t));
 
        char *byte_buf = new char[len];
        memcpy(byte_buf, val, len);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, byte_buf, len);
#else
        d_out.write(reinterpret_cast<const char*>(&len), sizeof(int64_t));
        d_out.write(val, len);
#endif
    }
}
 
void D4StreamMarshaller::put_vector(char *val, int64_t num_bytes)
{
    assert(val);
    assert(num_bytes >= 0);
 
    checksum_update(val, num_bytes);
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[num_bytes];
        memcpy(buf, val, num_bytes);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, num_bytes);
#else
        d_out.write(val, num_bytes);
#endif
    }
}
 
void D4StreamMarshaller::put_vector(char *val, int64_t num_elem, int elem_size)
{
        assert(val);
        assert(num_elem >= 0);
        assert(elem_size > 0);
 
        int64_t bytes;
 
        switch (elem_size) {
        case 1:
                assert(!"Don't call this method for bytes, use put_vector(val, bytes) instead");
                bytes = num_elem;
                break;
        case 2:
                // Don't bother testing the sign bit
                assert(!(num_elem & 0x4000000000000000)); // 0x 40 00 --> 0100 0000
                bytes = num_elem << 1;
                break;
        case 4:
                assert(!(num_elem & 0x6000000000000000)); // 0x 60 00 --> 0110 0000
                bytes = num_elem << 2;
                break;
        case 8:
                assert(!(num_elem & 0x7000000000000000)); // 0111 0000
                bytes = num_elem << 3;
                break;
        default:
                bytes = num_elem * elem_size;
                break;
        }
 
    checksum_update(val, bytes);
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[bytes];
        memcpy(buf, val, bytes);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, bytes);
#else
        d_out.write(val, bytes);
#endif
    }
}
 
void D4StreamMarshaller::put_vector_float32(char *val, int64_t num_elem)
{
#if !USE_XDR_FOR_IEEE754_ENCODING
 
        assert(std::numeric_limits<float>::is_iec559);
        assert(val);
        assert(num_elem >= 0);
        // sizeof() a 32-bit float is 4, so we're going to send 4 * num_elem bytes, so
        // make sure that doesn't overflow a 63-bit integer (the max positive value in
        // a signed int64; use 1110 0000 0.. (0xe000 ...) to mask for non-zero bits
        // to test that num can be multiplied by 4. A
        assert(!(num_elem & 0xe000000000000000));
 
        num_elem = num_elem << 2;       // num_elem is now the number of bytes
 
    checksum_update(val, num_elem);
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[num_elem];
        memcpy(buf, val, num_elem);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, num_elem);
#else
        d_out.write(val, num_elem);
#endif
    }
 
#else
        assert(val);
        assert(num_elem >= 0);
        // sizeof() a 32-bit float is 4, so we're going to send 4 * num_elem bytes, so
        // make sure that doesn't overflow a 63-bit integer (the max positive value in
        // a signed int64; use 1110 0000 0.. (0xe000 ...) to mask for non-zero bits
        // to test that num can be multiplied by 4. A
        assert(!(num_elem & 0xe000000000000000));
 
        int64_t bytes = num_elem << 2;  // num_elem is now the number of bytes
 
    checksum_update(val, bytes);
 
    if (d_write_data) {
        if (!std::numeric_limits<float>::is_iec559) {
            // If not using IEEE 754, use XDR to get it that way.
            m_serialize_reals(val, num_elem, 4, type);
        }
        else {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[bytes];
        memcpy(buf, val, bytes);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, bytes);
#else
        d_out.write(val, bytes);
#endif
        }
    }
#endif
}
 
void D4StreamMarshaller::put_vector_float64(char *val, int64_t num_elem)
{
#if !USE_XDR_FOR_IEEE754_ENCODING
 
        assert(std::numeric_limits<double>::is_iec559);
        assert(val);
        assert(num_elem >= 0);
        // See comment above
        assert(!(num_elem & 0xf000000000000000));
 
        num_elem = num_elem << 3;       // num_elem is now the number of bytes
 
    checksum_update(val, num_elem);
 
    if (d_write_data) {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[num_elem];
        memcpy(buf, val, num_elem);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, num_elem);
#else
        d_out.write(val, num_elem);
#endif
    }
#else
        assert(val);
        assert(num_elem >= 0);
        // sizeof() a 32-bit float is 4, so we're going to send 4 * num_elem bytes, so
        // make sure that doesn't overflow a 63-bit integer (the max positive value in
        // a signed int64; use 1110 0000 0.. (0xe000 ...) to mask for non-zero bits
        // to test that num can be multiplied by 4. A
        assert(!(num_elem & 0xe000000000000000));
 
        int64_t bytes = num_elem << 3;  // num_elem is now the number of bytes
 
    checksum_update(val, bytes);
 
    if (d_write_data) {
        if (!std::numeric_limits<double>::is_iec559) {
            // If not using IEEE 754, use XDR to get it that way.
            m_serialize_reals(val, num_elem, 8, type);
        }
        else {
#ifdef USE_POSIX_THREADS
        Locker lock(tm->get_mutex(), tm->get_cond(), tm->get_child_thread_count());
 
        char *buf = new char[bytes];
        memcpy(buf, val, bytes);
 
        tm->increment_child_thread_count();
        tm->start_thread(MarshallerThread::write_thread, d_out, buf, bytes);
#else
        d_out.write(val, bytes);
#endif
        }
    }
#endif
 
}
 
void D4StreamMarshaller::put_vector_part(char *val, unsigned int num, int width, Type type)
{
    assert(val);
    assert(num >= 0);
    assert(width > 0);
 
    switch(type) {
    case dods_byte_c:
    case dods_char_c:
    case dods_int8_c:
    case dods_uint8_c:
        put_vector(val, num);
        break;
 
    case dods_int16_c:
    case dods_uint16_c:
    case dods_int32_c:
    case dods_uint32_c:
    case dods_int64_c:
    case dods_uint64_c:
        put_vector(val, num, width);
        break;
 
    case dods_enum_c:
        if (width == 1)
            put_vector(val, num);
        else
            put_vector(val, num, width);
        break;
 
    case dods_float32_c:
        put_vector_float32(val, num);
        break;
 
    case dods_float64_c:
        put_vector_float32(val, num);
        break;
 
    case dods_str_c:
    case dods_url_c:
        throw InternalErr(__FILE__, __LINE__, "Array of String should not be passed to put_vector.");
 
    case dods_array_c:
        throw InternalErr(__FILE__, __LINE__, "Array of Array not allowed.");
 
    case dods_opaque_c:
    case dods_structure_c:
    case dods_sequence_c:
        throw InternalErr(__FILE__, __LINE__, "Array of String should not be passed to put_vector.");
 
    case dods_grid_c:
        throw InternalErr(__FILE__, __LINE__, "Grid is not part of DAP4.");
 
    default:
        throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");
        break;
    }
}
 
void D4StreamMarshaller::dump(ostream &strm) const
{
    strm << DapIndent::LMarg << "D4StreamMarshaller::dump - (" << (void *) this << ")" << endl;
}
 
} // namespace libdap