// -*- mode: c++; c-basic-offset:4 -*-

// This file is part of libdap, A C++ implementation of the OPeNDAP Data

// Access Protocol.

// Copyright (c) 2002,2003 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

//

// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.

// (c) COPYRIGHT URI/MIT 1995-1999

// Please read the full copyright statement in the file COPYRIGHT_URI.

//

// Authors:

//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>

// Implementation for class Vector. This class is the basis for all the

// vector-type classes in libdap's <Array, List>.

//

// 11/21/95 jhrg

#include "config.h"

#include <cstring>

#include <cassert>

//#define DODS_DEBUG 1

#include <sstream>

#include <vector>

#include <algorithm>

#include <typeinfo>

#include <stdint.h>

#include "crc.h"

#include "Vector.h"

#include "Marshaller.h"

#include "UnMarshaller.h"

#include "D4StreamMarshaller.h"

#include "D4StreamUnMarshaller.h"

#include "D4Enum.h"

#include "Type.h"

#include "dods-datatypes.h"

#include "escaping.h"

#include "util.h"

#include "debug.h"

#include "InternalErr.h"

#undef CLEAR_LOCAL_DATA

using std::cerr;

using std::endl;

namespace libdap {

void Vector::m_duplicate(const Vector & v)

{

    d_length = v.d_length;

    // _var holds the type of the elements. That is, it holds a BaseType

    // which acts as a template for the type of each element.

    if (v.d_proto) {

        d_proto = v.d_proto->ptr_duplicate(); // use ptr_duplicate()

        d_proto->set_parent(this); // ptr_duplicate does not set d_parent.

    }

    else {

        d_proto = 0;

    }

    // d_compound_buf and d_buf (further down) hold the values of the Vector. The field

    // d_compound_buf is used when the Vector holds non-numeric data (including strings

    // although it used to be that was not the case jhrg 2/10/05) while d_buf

    // holds numeric values.

    if (v.d_compound_buf.empty()) {

        d_compound_buf = v.d_compound_buf;

    }

    else {

        // Failure to set the size will make the [] operator barf on the LHS

        // of the assignment inside the loop.

        d_compound_buf.resize(d_length);

        for (int i = 0; i < d_length; ++i) {

            // There's no need to call set_parent() for each element; we

            // maintain the back pointer using the d_proto member. These

            // instances are used to hold _values_ only while the d_proto

            // field holds the type information for the elements.

            d_compound_buf[i] = v.d_compound_buf[i]->ptr_duplicate();

        }

    }

    // copy the strings. This copies the values.

    d_str = v.d_str;

    // copy numeric values if there are any.

    d_buf = 0; // init to null

    if (v.d_buf) // only copy if data present

        val2buf(v.d_buf); // store v's value in this's _BUF.

    d_capacity = v.d_capacity;

}

/**

 * @return whether the type of this Vector is a cardinal type

 * (i.e., stored in d_buf)

 */

bool Vector::m_is_cardinal_type() const

{

    // Not cardinal if no d_proto at all!

    if (!d_proto) {

        return false;

    }

    switch (d_proto->type()) {

        case dods_byte_c:

        case dods_char_c:

        case dods_int16_c:

        case dods_uint16_c:

        case dods_int32_c:

        case dods_uint32_c:

        case dods_float32_c:

        case dods_float64_c:

        	// New cardinal types for DAP4

        case dods_int8_c:

        case dods_uint8_c:

        case dods_int64_c:

        case dods_uint64_c:

        case dods_enum_c:

            return true;

            break;

            // These must be handled differently.

        case dods_str_c:

        case dods_url_c:

        case dods_opaque_c:

        case dods_array_c:

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            return false;

            break;

        default:

            assert("Vector::var: Unrecognized type");

            return false;

    }

}

/**

 * Create _buf so that it can store numElts of the

 * (assumed) cardinal type.  This create storage for

 * width() * numElts bytes.

 * If _buf already exists, this DELETES IT and creates a new one.

 * So don't use this if you want to keep the original _buf data around.

 * This also sets the valueCapacity().

 * @param numEltsOfType the number of elements of the cardinal type in var()

 that we want storage for.

 * @return the size of the buffer created.

 * @exception if the Vector's type is not cardinal type.

 */

unsigned int Vector::m_create_cardinal_data_buffer_for_type(unsigned int numEltsOfType)

{

    // Make sure we HAVE a _var, or we cannot continue.

    if (!d_proto) {

        throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: Logic error: _var is null!");

    }

    // Make sure we only do this for the correct data types.

    if (!m_is_cardinal_type()) {

        throw InternalErr(__FILE__, __LINE__, "create_cardinal_data_buffer_for_type: incorrectly used on Vector whose type was not a cardinal (simple data types).");

    }

    m_delete_cardinal_data_buffer();

    // Handle this special case where this is an array that holds no values

    if (numEltsOfType == 0)

        return 0;

    // Actually new up the array with enough bytes to hold numEltsOfType of the actual type.

    unsigned int bytesPerElt = d_proto->width();

    unsigned int bytesNeeded = bytesPerElt * numEltsOfType;

    d_buf = new char[bytesNeeded];

    d_capacity = numEltsOfType;

    return bytesNeeded;

}

/** Delete d_buf and zero it and d_capacity out */

void Vector::m_delete_cardinal_data_buffer()

{

	delete[] d_buf;

	d_buf = 0;

	d_capacity = 0;

}

/** Helper to reduce cut and paste in the virtual's.

 *

 */

template<class CardType>

void Vector::m_set_cardinal_values_internal(const CardType* fromArray, int numElts)

{

    if (numElts < 0) {

        throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with negative numElts!");

    }

    if (!fromArray) {

        throw InternalErr(__FILE__, __LINE__, "Logic error: Vector::set_cardinal_values_internal() called with null fromArray!");

    }

    set_length(numElts);

    m_create_cardinal_data_buffer_for_type(numElts);

    memcpy(d_buf, fromArray, numElts * sizeof(CardType));

    set_read_p(true);

}

/** The Vector constructor requires the name of the variable to be

 created, and a pointer to an object of the type the Vector is to

 hold.  The name may be omitted, which will create a nameless

 variable.  The template object may not be omitted.

 @param n A string containing the name of the variable to be

 created.

 @param v A pointer to a prototype for elements.

 @param t The type of the resulting Vector object, from the Type

 enum list.  There is no DAP2 Vector object, so all uses of this

 method will be from the Array class.  This defaults to

 <tt>dods_null_c</tt>.

 @see Type

 @brief The Vector constructor.  */

Vector::Vector(const string & n, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :

    BaseType(n, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)

{

    if (v)

        add_var(v);

    DBG2(cerr << "Entering Vector ctor for object: " << this << endl);

    if (d_proto)

        d_proto->set_parent(this);

}

/** The Vector server-side constructor requires the name of the variable

 to be created, the dataset name from which this Vector is created, and

 a pointer to an object of the type the Vector is to hold.  The

 name may be omitted, which will create a nameless variable.

 The template object may not be omitted.

 @param n A string containing the name of the variable to be

 created.

 @param d A string containing the dataset name from which the variable is

 being created.

 @param v A pointer to a prototype for elements.

 @param t The type of the resulting Vector object, from the Type

 enum list.  There is no DAP2 Vector object, so all uses of this

 method will be from the Array class.  This defaults to

 <tt>dods_null_c</tt>.

 @see Type

 @brief The Vector constructor.  */

Vector::Vector(const string & n, const string &d, BaseType * v, const Type & t, bool is_dap4 /* default:false */) :

    BaseType(n, d, t, is_dap4), d_length(-1), d_proto(0), d_buf(0), d_compound_buf(0), d_capacity(0)

{

    if (v)

        add_var(v);

    DBG2(cerr << "Entering Vector ctor for object: " << this << endl);

    if (d_proto)

        d_proto->set_parent(this);

}

/** The Vector copy constructor. */

Vector::Vector(const Vector & rhs) :

    BaseType(rhs)

{

    DBG2(cerr << "Entering Vector const ctor for object: " << this <<

            endl); DBG2(cerr << "RHS: " << &rhs << endl);

    m_duplicate(rhs);

}

Vector::~Vector()

{

    DBG2(cerr << "Entering ~Vector (" << this << ")" << endl);

    delete d_proto;

    d_proto = 0;

    // Clears all buffers

    clear_local_data();

    DBG2(cerr << "Exiting ~Vector" << endl);

}

Vector & Vector::operator=(const Vector & rhs)

{

    if (this == &rhs)

        return *this;

    dynamic_cast<BaseType &> (*this) = rhs;

    m_duplicate(rhs);

    return *this;

}

void Vector::set_name(const std::string& name)

{

    BaseType::set_name(name);

    // We need to set the prototype name as well since

    // this is what gets output in the dds!  Otherwise, there's a mismatch.

    if (d_proto) {

        d_proto->set_name(name);

    }

}

int Vector::element_count(bool leaves)

{

    if (!leaves)

        return 1;

    else

    	return d_proto->element_count(leaves);

        // var() only works for simple types!

        // jhrg 8/19/13 return var(0)->element_count(leaves);

}

// These mfuncs set the _send_p and _read_p fields of BaseType. They differ

// from BaseType's version in that they set both the Vector object's copy of

// _send_p (_read_p) but also _VAR's copy. This does not matter much when _VAR

// is a scalar, but does matter when it is an aggregate.

/** This function sets the <tt>send_p</tt> flag for both the Vector itself

 and its element template.  This does not matter much when the

 Vector contains simple data types, but does become significant

 when the Vector contains compound types.

 @brief Indicates that the data is ready to send. */

void Vector::set_send_p(bool state)

{

    if (d_proto) {

        d_proto->set_send_p(state);

        // because some code may depend on the BaseType*s held in d_compound_buf

        // behaving as if they are 'ordinary' DAP variables, make sure their send_p

        // flag is set if they exist. Because space in the vector is allocated

        // before values (BaseType*s) are added, check for nulls and limit the

        // iteration to only those elements actually in the object including any

        // constraints that may have been applied - these are values not declarations.

        // jhrg 5/13/16

        switch (d_proto->type()) {

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            if (d_compound_buf.size() > 0) {

                for (unsigned long long i = 0; i < (unsigned) d_length; ++i) {

                    if (d_compound_buf[i]) d_compound_buf[i]->set_send_p(state);

                }

            }

            break;

        default:

            break;

        }

    }

    BaseType::set_send_p(state);

}

/** This function sets the <tt>read_p</tt> flag for both the Vector itself

 and its element template.  This does not matter much when the

 Vector contains simple data types, but does become significant

 when the Vector contains compound types.

 @brief Indicates that the data is ready to send.  */

void Vector::set_read_p(bool state)

{

    if (d_proto) {

        d_proto->set_read_p(state);

        // See comment above.

        switch (d_proto->type()) {

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            if (d_compound_buf.size() > 0) {

                for (unsigned long long i = 0; i < (unsigned)d_length; ++i) {

                    if (d_compound_buf[i]) d_compound_buf[i]->set_read_p(state);

                }

            }

            break;

        default:

            break;

        }

    }

    BaseType::set_read_p(state);

}

/** Returns a copy of the template array element. If the Vector contains

 simple data types, the template will contain the value of the last

 vector element accessed with the Vector::var(int i) function,

 if any. If no such access has been made, or if the Vector contains

 compound data types, the value held by the template instance is

 undefined.

 Note that the parameter exact_match is not used by this mfunc.

 @param n The name of the variable to find.

 @param exact Unused.

 @param s Pointer to a BaseType Pointer Stack. Use this stack to record

 the path to the variable. By default this pointer is null, in which case

 it is not used.

 @return A pointer to the BaseType if found, otherwise null.

 @see Vector::var */

BaseType *Vector::var(const string &n, bool exact, btp_stack *s)

{

    string name = www2id(n);

    DBG2(cerr << "Vector::var: Looking for " << name << endl);

    if (name == "" || d_proto->name() == name) {

        if (s)

            s->push(this);

        return d_proto;

    }

    // If this is a Vector of constructor types, look for 'name' recursively.

    // Make sure to check for the case where name is the default (the empty

    // string). 9/1/98 jhrg

    if (d_proto->is_constructor_type()) {

        BaseType *result = d_proto->var(name, exact, s);

        if (result && s)

            s->push(this);

        return result;

    }

    return NULL;

}

/** This version of var(...) searches for name and returns a

 pointer to the BaseType object if found. It uses the same search

 algorithm as above when exact_match is false. In addition to

 returning a pointer to the variable, it pushes onto s a

 BaseType pointer to each constructor type that ultimately contains

 name.

 @param n Find the variable whose name is name.

 @param s Record the path to name.

 @return A pointer to the named variable. */

BaseType *Vector::var(const string & n, btp_stack & s)

{

    string name = www2id(n);

    if (d_proto->is_constructor_type())

        return d_proto->var(name, s);

    else {

        s.push((BaseType *) this);

        return d_proto;

    }

}

/** Returns a pointer to the specified Vector element.  The return

 pointer will reference the element itself, so multiple calls to this

 method should save each value before making the next call.

 @param i The index of the desired Vector element.  Zero

 indicates the first element of the Vector.

 @return A pointer to a BaseType class instance containing

 the value of the indicated element. The BaseType pointer is locally

 maintained and should not be deleted or referenced. Extract the value

 right after the method returns.

 @see BaseType::var */

BaseType *Vector::var(unsigned int i)

{

    switch (d_proto->type()) {

        case dods_byte_c:

        case dods_char_c:

        case dods_int8_c:

        case dods_uint8_c:

        case dods_int16_c:

        case dods_uint16_c:

        case dods_int32_c:

        case dods_uint32_c:

        case dods_int64_c:

        case dods_uint64_c:

        case dods_enum_c:

        case dods_float32_c:

        case dods_float64_c:

            // Transfer the ith value to the BaseType *d_proto

            d_proto->val2buf(d_buf + (i * d_proto->width()));

            return d_proto;

            break;

        case dods_str_c:

        case dods_url_c:

            d_proto->val2buf(&d_str[i]);

            return d_proto;

            break;

        case dods_opaque_c:

        case dods_array_c:

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            return d_compound_buf[i];

            break;

        default:

            throw Error ("Vector::var: Unrecognized type");

            break;

    }

    return 0;

}

/** Returns the number of bytes needed to hold the entire

 array.  This is equal to \c length() (the number of elements in

 in the array) times the width of each

 element.

 @brief Returns the width of the data, in bytes. */

unsigned int Vector::width(bool constrained) const

{

    // Jose Garcia

	assert(d_proto);

    return length() * d_proto->width(constrained);

}

/** Returns the number of elements in the vector. Note that some

 child classes of Vector use the length of -1 as a flag value.

 @see Vector::append_dim */

int Vector::length() const

{

    return d_length;

}

/** Sets the length of the vector.  This function does not allocate

 any new space. */

void Vector::set_length(int l)

{

    d_length = l;

}

/** Resizes a Vector.  If the input length is greater than the

 current length of the Vector, new memory is allocated (the

 Vector moved if necessary), and the new entries are appended to

 the end of the array and padded with Null values.  If the input

 length is shorter, the tail values are discarded.

 @note This method is applicable to the compound types only.

 */

void Vector::vec_resize(int l)

{

    // I added this check, which alters the behavior of the method. jhrg 8/14/13

    if (m_is_cardinal_type())

        throw InternalErr(__FILE__, __LINE__, "Vector::vec_resize() is applicable to compound types only");

    // Use resize() since other parts of the code use operator[]. Note that size() should

    // be used when resize() is used. Using capacity() creates problems as noted in the

    // comment in set_vec_nocopy(). jhrg 5/19/17

    d_compound_buf.resize(l, 0); // Fill with NULLs

    d_capacity = d_compound_buf.size(); // size in terms of number of elements.

}

/** @brief read data into a variable for later use

 Most uses of a variable are to either serialize its data to a stream of

 some sort or to read values from some stream and intern those in the

 variable for later use. These operations are perform by serialize()

 and deserialize() which follow. This function performs essentially both

 of these operations without actually using a stream device. The data are

 read using the read() method(s) and loaded into the variables directly.

 This method is intended to be used by objects which transform DAP objects

 like the DataDDS into an ASCII CSV representation.

 @note A DAP2-only method

 @param eval A reference to a constraint evaluator

 @param dds The complete DDS to which this variable belongs */

void Vector::intern_data(ConstraintEvaluator &eval, DDS &dds)

{

    DBG(cerr << "Vector::intern_data: " << name() << endl);

    if (!read_p())

        read(); // read() throws Error and InternalErr

    // length() is not capacity; it must be set explicitly in read().

    int num = length();

    switch (d_proto->type()) {

        case dods_byte_c:

        case dods_int16_c:

        case dods_uint16_c:

        case dods_int32_c:

        case dods_uint32_c:

        case dods_float32_c:

        case dods_float64_c:

            // For these cases, read() puts the data into d_buf,

        	// which is what we need.

            break;

        case dods_str_c:

        case dods_url_c:

            // For these cases, read() will put the data into d_str[],

        	// which is also what we need.

            break;

        case dods_array_c:

            // This is an error since there can never be an Array of Array.

            throw InternalErr(__FILE__, __LINE__, "Array of Array not supported.");

            break;

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            DBG(cerr << "Vector::intern_data: found ctor" << endl);

            // For these cases, we need to call read() for each of the 'num'

            // elements in the 'd_compound_buf[]' array of BaseType object pointers.

            //

            // I changed the test here from '... = 0' to '... < num' to accommodate

            // the case where the array is zero-length.

            if (d_compound_buf.capacity() < (unsigned)num)

                throw InternalErr(__FILE__, __LINE__, "The capacity of this Vector is less than the number of elements.");

            for (int i = 0; i < num; ++i)

                d_compound_buf[i]->intern_data(eval, dds);

            break;

        default:

            throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");

            break;

    }

}

/** @brief Serialize a Vector.

 This uses the Marshaler class to encode each element of a cardinal

 array. For Arrays of Str and Url types, send the element count over

 as a prefix to the data so that deserialize will know how many elements

 to read.

 NB: Arrays of cardinal types must already be in BUF (in the local machine's

 representation) before this call is made.

 */

bool Vector::serialize(ConstraintEvaluator & eval, DDS & dds, Marshaller &m, bool ce_eval)

{

#if 0

    dds.timeout_on();

#endif

    // Added to streamline zero-length arrays. Not needed for correct function,

    // but explicitly handling this case here makes the code easier to follow.

    // In libdap::Vector::val2buf() there is a test that will catch the zero-length

    // case as well. We still need to call serialize since it will write size

    // information that the client depends on. jhrg 2/17/16

    if (length() == 0)

        set_read_p(true);

    else if (!read_p())

        read(); // read() throws Error and InternalErr

    if (ce_eval && !eval.eval_selection(dds, dataset()))

        return true;

#if 0

    dds.timeout_off();

#endif

    // length() is not capacity; it must be set explicitly in read().

    int num = length();

    bool status = false;

    switch (d_proto->type()) {

        case dods_byte_c:

            m.put_vector(d_buf, num, *this);

            status = true;

            break;

        case dods_int16_c:

        case dods_uint16_c:

        case dods_int32_c:

        case dods_uint32_c:

        case dods_float32_c:

        case dods_float64_c:

            m.put_vector(d_buf, num, d_proto->width(), *this);

            status = true;

            break;

        case dods_str_c:

        case dods_url_c:

            if (d_str.capacity() == 0)

                throw InternalErr(__FILE__, __LINE__, "The capacity of the string vector is 0");

            m.put_int(num);

            for (int i = 0; i < num; ++i)

                m.put_str(d_str[i]);

            status = true;

            break;

        case dods_array_c:

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            //Jose Garcia

            // Not setting the capacity of d_compound_buf is an internal error.

            if (d_compound_buf.capacity() == 0)

                throw InternalErr(__FILE__, __LINE__, "The capacity of *this* vector is 0.");

            m.put_int(num);

            status = true;

            for (int i = 0; i < num && status; ++i)

                status = status && d_compound_buf[i]->serialize(eval, dds, m, false);

            break;

        default:

            throw InternalErr(__FILE__, __LINE__, "Unknown datatype.");

            break;

    }

#ifdef CLEAR_LOCAL_DATA

    clear_local_data();

#endif

    return status;

}

// Read an object from the network and internalize it. For a Vector this is

// handled differently for a `cardinal' type. Vectors of Cardinals are

// stored using the `C' representations because these objects often are used

// to build huge arrays (e.g., an array of 1024 by 1024 bytes). However,

// arrays of non-cardinal types are stored as Vectors of the C++ objects or

// DAP2 objects (Str and Url are vectors of the string class, Structure, ...,

// Grid are vectors of the libdap Structure, ... classes).

//

// The boolean parameter REUSE determines whether internal storage is reused

// or not. If true, the _buf member is assumed to be large enough to hold the

// incoming cardinal data and is *not* reallocated. If false, new storage is

// allocated. If the internal buffer has not yet been allocated, then this

// parameter has no effect (i.e., storage is allocated). This parameter

// effects storage for cardinal data only.

//

// Returns: True is successful, false otherwise.

bool Vector::deserialize(UnMarshaller &um, DDS * dds, bool reuse)

{

    unsigned int num;

    unsigned i = 0;

    switch (d_proto->type()) {

        case dods_byte_c:

        case dods_int16_c:

        case dods_uint16_c:

        case dods_int32_c:

        case dods_uint32_c:

        case dods_float32_c:

        case dods_float64_c:

            um.get_int((int &) num);

            DBG(cerr << "Vector::deserialize: num = " << num << endl);

            DBG(cerr << "Vector::deserialize: length = " << length() << endl);

            if (length() == -1)

                set_length(num);

            if (num != (unsigned int) length())

                throw InternalErr(__FILE__, __LINE__, "The server sent declarations and data with mismatched sizes for the variable '" + name() + "'.");

            if (!d_buf || !reuse) {

                // Make d_buf be large enough for length() elements of _var->type()

            	// m_create...() deletes the old buffer.

                m_create_cardinal_data_buffer_for_type(length());

                DBG(cerr << "Vector::deserialize: allocating "

                        << width() << " bytes for an array of "

                        << length() << " " << d_proto->type_name() << endl);

            }

            // Added to accommodate zero-length arrays.

            // Note that the rest of the cases will just send the size without data

            // but that these calls trigger error testing in the UnMarshaller code.

            // jhrg 1/28/16

            if (num == 0)

                return true;

            if (d_proto->type() == dods_byte_c)

                um.get_vector((char **) &d_buf, num, *this);

            else

                um.get_vector((char **) &d_buf, num, d_proto->width(), *this);

            DBG(cerr << "Vector::deserialize: read " << num << " elements\n");

            break;

        case dods_str_c:

        case dods_url_c:

            um.get_int((int &) num);

            if (length() == -1)

                set_length(num);

            if (num != (unsigned int) length())

                throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");

            d_str.resize((num > 0) ? num : 0); // Fill with NULLs

            d_capacity = num; // capacity is number of strings we can fit.

            for (i = 0; i < num; ++i) {

                string str;

                um.get_str(str);

                d_str[i] = str;

            }

            break;

        case dods_array_c:

            // Added jhrg 5/18/17

            // This replaces a comment that was simply 'TO DO'

            throw InternalErr(__FILE__, __LINE__, "Array of array!");

            break;

        case dods_structure_c:

        case dods_sequence_c:

        case dods_grid_c:

            um.get_int((int &) num);

            if (length() == -1)

                set_length(num);

            if (num != (unsigned int) length())

                throw InternalErr(__FILE__, __LINE__, "The client sent declarations and data with mismatched sizes.");

            vec_resize(num);

            for (i = 0; i < num; ++i) {

                d_compound_buf[i] = d_proto->ptr_duplicate();

                d_compound_buf[i]->deserialize(um, dds);

            }

            break;

        default:

            throw InternalErr(__FILE__, __LINE__, "Unknown type!");

            break;

    }

    return false;

}

void Vector::compute_checksum(Crc32 &checksum)

{

    switch (d_proto->type()) {

        case dods_byte_c:

        case dods_char_c: