Array.cc

// -*- 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 1994-1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>
 
// Implementation for Array.
//
// jhrg 9/13/94
 
#include "config.h"
 
// #define DODS_DEBUG
 
#include <algorithm>
#include <functional>
#include <sstream>
 
#include "Array.h"
#include "Grid.h"
 
#include "D4Attributes.h"
#include "D4Dimensions.h"
#include "D4Enum.h"
#include "D4EnumDefs.h"
#include "D4Group.h"
#include "D4Maps.h"
#include "DMR.h"
#include "XMLWriter.h"
 
#include "DapIndent.h"
#include "InternalErr.h"
#include "debug.h"
#include "escaping.h"
#include "util.h"
 
using namespace std;
 
namespace libdap {
 
Array::dimension::dimension(D4Dimension *d) : dim(d), use_sdim_for_slice(true) {
    size = d->size();
    name = d->name();
 
    start = 0;
    stop = size - 1;
    stride = 1;
    c_size = size;
}
 
void Array::_duplicate(const Array &a) {
    _shape = a._shape;
 
    // Deep copy the Maps if they are being used.
    if (a.d_maps) {
        d_maps = new D4Maps(*a.d_maps, this);
    } else {
        d_maps = nullptr;
    }
}
 
// The first method of calculating length works when only one dimension is
// constrained, and you want the others to appear in the total. This is important
// when selecting from grids since users may not select from all dimensions
// in which case that means they want the whole thing. Array projection
// should probably work this way too, but it doesn't. 9/21/2001 jhrg

void Array::update_length(int) {
    uint64_t length = 1;
    for (Dim_citer i = _shape.begin(); i != _shape.end(); i++) {
        length *= (*i).c_size;
    }
 
    set_length_ll(length);
}
 
void Array::update_length_ll(unsigned long long) {
    unsigned long long length = 1;
    for (const auto &i : _shape) {
        length *= i.c_size;
    }
 
    set_length_ll(length);
}
 
// Construct an instance of Array. The (BaseType *) is assumed to be
// allocated using new - The dtor for Vector will delete this object.

Array::Array(const string &n, BaseType *v, bool is_dap4 /* default:false */)
    : Vector(n, nullptr, dods_array_c, is_dap4) {
    Array::add_var(v);
    if (v)
        BaseType::set_is_dap4(v->is_dap4());
}

Array::Array(const string &n, const string &d, BaseType *v, bool is_dap4 /* default:false */)
    : Vector(n, d, nullptr, dods_array_c, is_dap4) {
    Array::add_var(v);
    if (v)
        BaseType::set_is_dap4(v->is_dap4());
}

Array::Array(const Array &rhs) : Vector(rhs) { _duplicate(rhs); }

Array::~Array() { delete d_maps; }
 
BaseType *Array::ptr_duplicate() { return new Array(*this); }
 
Array &Array::operator=(const Array &rhs) {
    if (this == &rhs)
        return *this;
    Vector::operator=(rhs);
    _duplicate(rhs);
    return *this;
}
 
void Array::transform_to_dap4(D4Group *root, Constructor *container) {
    Array *dest = static_cast<Array *>(ptr_duplicate());
 
    // If it's already a DAP4 object then we can just return it!
    if (is_dap4()) {
        container->add_var_nocopy(dest);
    }
 
    // Process the Array's dimensions, making D4 shared dimensions for
    // D2 dimensions that are named. If there is just a size, don't make
    // a D4Dimension (In DAP4 you cannot share a dimension unless it has
    // a name). jhrg 3/18/14
 
    D4Dimensions *root_dims = root->dims();
    for (Array::Dim_iter dap2_dim = dest->dim_begin(), e = dest->dim_end(); dap2_dim != e; ++dap2_dim) {
        if (!(*dap2_dim).name.empty()) {
 
            // If a D4Dimension with the name already exists, use it.
            D4Dimension *d4_dim = root_dims->find_dim((*dap2_dim).name);
            if (!d4_dim) {
                d4_dim = new D4Dimension((*dap2_dim).name, (*dap2_dim).size);
                root_dims->add_dim_nocopy(d4_dim);
            } else {
                DBG(cerr << __func__ << "() -" << " Using Existing D4Dimension '" << d4_dim->name() << "' ("
                         << (void *)d4_dim << ")" << endl);
                ;
 
                if (d4_dim->size() != (unsigned long)(*dap2_dim).size) {
                    // TODO Revisit this decision. jhrg 3/18/14
                    // ...in case the name/size are different, make a unique D4Dimension
                    // but don't fiddle with the name. Not sure I like this idea, so I'm
                    // making the case explicit (could be rolled in to the block above).
                    // jhrg 3/18/14
                    //
                    // This is causing problems in the FITS handler because there are cases
                    // where two arrays have dimensions with the same name but different
                    // sizes. The deserializing code is using the first size listed, which is
                    // wrong in some cases. I'm going to try making this new D4Dimension using
                    // the dim name along with the variable name. jhrg 8/15/14
                    d4_dim = new D4Dimension((*dap2_dim).name + "_" + name(), (*dap2_dim).size);
                    DBG(cerr << __func__ << "() -" << " Utilizing Name/Size Conflict Naming Artifice. name'"
                             << d4_dim->name() << "' (" << (void *)d4_dim << ")" << endl);
                    ;
                    root_dims->add_dim_nocopy(d4_dim);
                }
            }
            // At this point d4_dim's name and size == those of (*d) so just set
            // the D4Dimension pointer so that it matches the one in the D4Group.
            (*dap2_dim).dim = d4_dim;
        }
    }
 
    // Copy the D2 attributes to D4 Attributes
    dest->attributes()->transform_to_dap4(get_attr_table());
    dest->set_is_dap4(true);
    container->add_var_nocopy(dest);
}
 
bool Array::is_dap2_grid() {
    bool is_grid = false;
    if (this->is_dap4()) {
        DBG(cerr << __func__ << "() - Array '" << name() << "' is DAP4 object!" << endl);
        auto root = dynamic_cast<D4Group *>(this->get_ancestor());
        if (!root)
            throw InternalErr(__FILE__, __LINE__, string("Could not get the root group for ").append(this->name()));
        D4Maps *d4_maps = this->maps();
        is_grid = d4_maps->size(); // It can't be a grid if there are no maps...
 
        // We also need to check if the number of maps is the same as the number of dimensions. If not, this is not a
        // dap2 grid.
        if (d4_maps->size() != ((int)dimensions()))
            is_grid = false;
        if (is_grid) {
            DBG(cerr << __func__ << "() - Array '" << name() << "' has D4Maps." << endl);
            // hmmm this might be a DAP2 Grid...
            D4Maps::D4MapsIter i = d4_maps->map_begin();
            D4Maps::D4MapsIter e = d4_maps->map_end();
 
            while (i != e) {
                DBG(cerr << __func__ << "() - Map '" << (*i)->array()->name() << " has " << (*i)->array()->_shape.size()
                         << " dimension(s)." << endl);
                if ((*i)->array(root)->_shape.size() > 1) {
                    is_grid = false;
                    i = e;
                } else {
                    i++;
                }
            }
        } else {
            DBG(cerr << __func__ << "() - Array '" << name() << "' has no D4Maps." << endl);
        }
    }
 
    DBG(cerr << __func__ << "() - is_grid: " << (is_grid ? "true" : "false") << endl);
    return is_grid;
}

std::vector<BaseType *> *Array::transform_to_dap2(AttrTable *) {
    DBG(cerr << __func__ << "() - BEGIN Array '" << name() << "'" << endl);
    ;
 
    BaseType *dest;
    if (!is_dap4()) { // Don't convert a DAP2 thing
        dest = ptr_duplicate();
    } else {
        // At this point we have a DAP4 Array. It have D4Attributes and nothing
        // in the DAP2 AttrTable (which is held as a reference, defined in BaseType).
        // This test determines in the D4 Array qualifies as a D2 Grid.
        if (is_dap2_grid()) {
            // Oh yay! Grids are special.
            DBG(cerr << __func__ << "() - Array '" << name() << "' is dap2 Grid!" << endl);
            ;
            Grid *g = new Grid(name());
            dest = g;
            Array *grid_array = static_cast<Array *>(ptr_duplicate());
            grid_array->set_is_dap4(false);
            g->set_array(grid_array);
 
            // Fix for HK-403. jhrg 6/17/19
            attributes()->transform_attrs_to_dap2(&grid_array->get_attr_table());
 
            // Process the Map Arrays.
            auto root = dynamic_cast<D4Group *>(this->get_ancestor());
            if (!root)
                throw InternalErr(__FILE__, __LINE__, string("Could not get the root group for ").append(this->name()));
            D4Maps *d4_maps = this->maps();
            vector<BaseType *> dropped_maps;
            D4Maps::D4MapsIter miter = d4_maps->map_begin();
            D4Maps::D4MapsIter end = d4_maps->map_end();
            for (; miter != end; miter++) {
                D4Map *d4_map = (*miter);
                Array *d4_map_array = const_cast<Array *>(d4_map->array(root));
                vector<BaseType *> *d2_result = d4_map_array->transform_to_dap2(&(g->get_attr_table()));
                if (d2_result) {
                    if (d2_result->size() > 1)
                        throw Error(internal_error, "D4Map Array conversion resulted in multiple DAP2 objects.");
 
                    // TODO - This is probably slow and needs a better pattern. const_cast? static_cast?
                    Array *d2_map_array = dynamic_cast<Array *>((*d2_result)[0]);
                    if (d2_map_array) {
                        if (d2_map_array->dimensions() != 1)
                            throw Error(internal_error,
                                        "DAP2 array from D4Map Array conversion has more than 1 dimension.");
 
                        d2_map_array->set_is_dap4(false);
                        g->add_map(d2_map_array, false);
                        AttrTable at = d2_map_array->get_attr_table();
                        DBG(cerr << __func__ << "() - " << "DAS For Grid Map '" << d2_map_array->name() << "':" << endl;
                            at.print(cerr););
                    } else {
                        throw Error(internal_error, "Unable to interpret returned DAP2 content.");
                    }
                    delete d2_result;
                } else {
                    dropped_maps.push_back(d4_map_array);
                }
            }
 
            // Did we have a transform failure?
            if (!dropped_maps.empty()) {
                // Yup... tell the story in the attributes.
                AttrTable *dv_table = Constructor::make_dropped_vars_attr_table(&dropped_maps);
                dest->get_attr_table().append_container(dv_table, dv_table->get_name());
            }
        } else {
            DBG(cerr << __func__ << "() - Array '" << name() << "' is not a Grid!" << endl);
 
            BaseType *proto = prototype();
            switch (proto->type()) {
            case dods_int64_c:
            case dods_uint64_c:
            case dods_enum_c:
            case dods_opaque_c:
                // For now we punt on these types as they have no easy representation in
                // the DAP2 data model. By setting this to NULL we cause the Array to be
                // dropped and this will be reflected in the metadata (DAS).
                dest = NULL;
                break;
 
            default:
                // ptr_duplicate() does the Attributes too.
                dest = ptr_duplicate();
 
                // Fix for HK-403. jhrg 6/17/19
                // Only transform the DAP4 attributes to DAP2 ones if the DAP2 object lacks
                // attributes. If the new DAP2 variable already has attributes, they were
                // added by this process (driven by D4Group::transform_to_dap2() and calling
                // attributes()->transform_to_dap2() will put a second copy of each attribute's
                // value in the DAP2 AttrTable. This attribute transform code (here and elsewhere)
                // depends on the AttrTable for a DAP4 variable initially being empty. Once it
                // contains attributes, the code assumes they were put there by this transform
                // process. jhrg 6/18/19
                if (dest->get_attr_table().get_size() == 0) {
                    attributes()->transform_attrs_to_dap2(&dest->get_attr_table());
                    dest->get_attr_table().set_name(name());
                }
 
                dest->set_is_dap4(false);
                break;
            }
        }
    }
 
    vector<BaseType *> *result;
    if (dest) {
        result = new vector<BaseType *>();
        result->push_back(dest);
    } else {
        result = NULL;
    }
 
    DBG(cerr << __func__ << "() - END Array '" << name() << "'" << endl);
    ;
    return result;
}

void Array::update_dimension_pointers(D4Dimensions *old_dims, D4Dimensions *new_dims) {
    std::vector<dimension>::iterator i = _shape.begin(), e = _shape.end();
    while (i != e) {
        D4Dimensions::D4DimensionsIter old_i = old_dims->dim_begin(), old_e = old_dims->dim_end();
        while (old_i != old_e) {
            if ((*i).dim == *old_i) {
                (*i).dim = new_dims->find_dim((*old_i)->name());
            }
            ++old_i;
        }
 
        ++i;
    }
}

 
void Array::add_var(BaseType *v, Part) {
    // If 'v' is an Array, add the template instance to this object and
    // then copy the dimension information. Odd semantics; I wonder if this
    // is ever used. jhrg 6/13/12
    if (v && v->type() == dods_array_c) {
        Array *a = static_cast<Array *>(v);
        Vector::add_var(a->var());
 
        Dim_iter i = a->dim_begin();
        Dim_iter i_end = a->dim_end();
        while (i != i_end) {
            append_dim(a->dimension_size(i), a->dimension_name(i));
            ++i;
        }
    } else {
        Vector::add_var(v);
    }
}
 
void Array::add_var_nocopy(BaseType *v, Part) {
    // If 'v' is an Array, add the template instance to this object and
    // then copy the dimension information. Odd semantics; I wonder if this
    // is ever used. jhrg 6/13/12
    if (v && v->type() == dods_array_c) {
        Array &a = dynamic_cast<Array &>(*v);
        Vector::add_var_nocopy(a.var());
        Dim_iter i = a.dim_begin();
        Dim_iter i_end = a.dim_end();
        while (i != i_end) {
            append_dim(a.dimension_size(i), a.dimension_name(i));
            ++i;
        }
    } else {
        Vector::add_var_nocopy(v);
    }
}

void Array::append_dim(int size, const string &name) {
    dimension d(size, www2id(name));
    _shape.push_back(d);
 
    update_length();
}
 
void Array::append_dim_ll(int64_t size, const string &name) {
 
#if 0
    dimension d(size, www2id(name));
    _shape.push_back(d);
#endif
 
    _shape.emplace_back(size, www2id(name));
    update_length();
}
 
void Array::append_dim(D4Dimension *dim) {
    dimension d(/*dim->size(), www2id(dim->name()),*/ dim);
    _shape.push_back(d);
 
    update_length();
}

void Array::prepend_dim(int size, const string &name /* = "" */) {
    dimension d(size, www2id(name));
    // Shifts the whole array, but it's tiny in general
    _shape.insert(_shape.begin(), d);
 
    update_length(); // the number is ignored...
}
 
void Array::prepend_dim(D4Dimension *dim) {
    dimension d(/*dim->size(), www2id(dim->name()),*/ dim);
    // Shifts the whole array, but it's tiny in general
    _shape.insert(_shape.begin(), d);
 
    update_length(); // the number is ignored...
}

void Array::clear_all_dims() { _shape.clear(); }

 
void Array::rename_dim(const string &oldName, const string &newName) {
    std::vector<dimension>::iterator i = _shape.begin(), e = _shape.end();
    while (i != e) {
        dimension &d = *i;
        if (d.name == oldName) {
            DBG(cerr << "Old name = " << d.name << " newName = " << newName << endl);
            d.name = newName;
        }
 
        ++i;
    }
}

void Array::reset_constraint() {
    set_length(-1);
 
    for (Dim_iter i = _shape.begin(); i != _shape.end(); i++) {
        (*i).start = 0;
        (*i).stop = (*i).size - 1;
        (*i).stride = 1;
        (*i).c_size = (*i).size;
 
        update_length();
    }
}

void Array::clear_constraint() { reset_constraint(); }
 
// Note: MS VC++ won't tolerate embedded newlines in strings, hence the \n
// is explicit.
static const char *array_sss = "Invalid constraint parameters: At least one of the start, stride or stop \n\
specified do not match the array variable.";

void Array::add_constraint(Dim_iter i, int start, int stride, int stop) {
    dimension &d = *i;
 
    DBG(cerr << "add_constraint: d_size = " << d.size << endl);
    DBG(cerr << "add_constraint: start = " << start << endl);
    DBG(cerr << "add_constraint: stop = " << stop << endl);
    DBG(cerr << "add_constraint: stride = " << stride << endl);
 
    // if stop is -1, set it to the array's max element index
    // jhrg 12/20/12
    // Check if d.size is greater than INT_MAX, if yes, the following block needs to be re-worked. STOP
    if (stop == -1) {
        if (d.size > DODS_INT_MAX) {
            // The total size of this dimension is greater than the maximum 32-bit integer.
            throw Error(malformed_expr, "The dimension size is too large. use add_constraint_ll()");
        } else
            stop = d.size - 1;
    }
 
    // Check for bad constraints.
    // Jose Garcia
    // Usually invalid data for a constraint is the user's mistake
    // because they build a wrong URL in the client side.
    if (start >= d.size || stop >= d.size || stride > d.size || stride <= 0)
        throw Error(malformed_expr, array_sss);
 
    if (((stop - start) / stride + 1) > d.size)
        throw Error(malformed_expr, array_sss);
 
    d.start = start;
    d.stop = stop;
    d.stride = stride;
 
    d.c_size = (stop - start) / stride + 1;
 
    DBG(cerr << "add_constraint: c_size = " << d.c_size << endl);
 
    update_length();
 
    d.use_sdim_for_slice = false;
}
 
void Array::add_constraint_ll(Dim_iter i, int64_t start, int64_t stride, int64_t stop) {
    dimension &d = *i;
    DBG(cerr << "add_constraint_ll: d_size = " << d.size << endl);
    DBG(cerr << "add_constraint_ll: start = " << start << endl);
    DBG(cerr << "add_constraint_ll: stop = " << stop << endl);
    DBG(cerr << "add_constraint_ll: stride = " << stride << endl);
 
    // if stop is -1, set it to the array's max element index
    // jhrg 12/20/12
    if (stop == -1)
        stop = d.size - 1;
 
    // Check for bad constraints.
    // Jose Garcia
    // Usually invalid data for a constraint is the user's mistake
    // because they build a wrong URL in the client side.
    if (start >= d.size || stop >= d.size || stride > d.size || stride <= 0)
        throw Error(malformed_expr, array_sss);
 
    if (((stop - start) / stride + 1) > d.size)
        throw Error(malformed_expr, array_sss);
 
    d.start = start;
    d.stop = stop;
    d.stride = stride;
 
    d.c_size = (stop - start) / stride + 1;
 
    DBG(cerr << "add_constraint: c_size = " << d.c_size << endl);
 
    update_length();
 
    d.use_sdim_for_slice = false;
}
void Array::add_constraint(Dim_iter i, D4Dimension *dim) {
    dimension &d = *i;
    DBG(cerr << "add_constraint d4dimension: stride = " << dim->c_stride() << endl);
 
    if (dim->constrained())
        add_constraint_ll(i, dim->c_start(), dim->c_stride(), dim->c_stop());
 
    dim->set_used_by_projected_var(true);
 
    // In this case the value below overrides the value for use_sdim_for_slice
    // set in the above call. jhrg 12/20/13
    d.use_sdim_for_slice = true;
}

Array::Dim_iter Array::dim_begin() { return _shape.begin(); }

Array::Dim_iter Array::dim_end() { return _shape.end(); }
 
// TODO Many of these methods take a bool parameter that serves no use; remove.

unsigned int Array::dimensions(bool /*constrained*/) { return _shape.size(); }

int Array::dimension_size(Dim_iter i, bool constrained) {
    int size = 0;
 
    if (!_shape.empty()) {
        if (constrained) {
            if ((*i).c_size > DODS_INT_MAX) {
                throw Error(malformed_expr, "The dimension size is too large. Use dimension_size_ll()");
            } else
                size = (*i).c_size;
        } else {
            if ((*i).size > DODS_INT_MAX) {
                throw Error(malformed_expr, "The dimension size is too large. Use dimension_size_ll()");
            } else
                size = (*i).size;
        }
    }
 
    return size;
}

int Array::dimension_start(Dim_iter i, bool /*constrained*/) {
    if ((*i).start > DODS_INT_MAX) {
        throw Error(malformed_expr, "The dimension start value is too large. Use dimension_start_ll()");
    }
    return (!_shape.empty()) ? (*i).start : 0;
}

int Array::dimension_stop(Dim_iter i, bool /*constrained*/) {
    if ((*i).stop > DODS_INT_MAX) {
        throw Error(malformed_expr, "The dimension stop value is too large. Use dimension_stop_ll()");
    }
    return (!_shape.empty()) ? (*i).stop : 0;
}

int Array::dimension_stride(Dim_iter i, bool /*constrained*/) {
    if ((*i).stride > DODS_INT_MAX) {
        throw Error(malformed_expr, "The dimension stride value is too large. Use dimension_stride_ll()");
    }
    return (!_shape.empty()) ? (*i).stride : 0;
}
 
int64_t Array::dimension_size_ll(Dim_iter i, bool constrained) {
    int64_t size = 0;
 
    if (!_shape.empty()) {
        if (constrained)
            size = (*i).c_size;
        else
            size = (*i).size;
    }
    return size;
}
 
int64_t Array::dimension_start_ll(Dim_iter i, bool /*constrained*/) { return (!_shape.empty()) ? (*i).start : 0; }
 
int64_t Array::dimension_stop_ll(Dim_iter i, bool /*constrained*/) { return (!_shape.empty()) ? (*i).stop : 0; }
 
int64_t Array::dimension_stride_ll(Dim_iter i, bool /*constrained*/) { return (!_shape.empty()) ? (*i).stride : 0; }

string Array::dimension_name(Dim_iter i) {
    // Jose Garcia
    // Since this method is public, it is possible for a user
    // to call it before the Array object has been properly set
    // this will cause an exception which is the user's fault.
    // (User in this context is the developer of the surrogate library.)
    if (_shape.empty())
        throw InternalErr(__FILE__, __LINE__, "*This* array has no dimensions.");
    return (*i).name;
}
 
D4Dimension *Array::dimension_D4dim(Dim_iter i) { return (!_shape.empty()) ? (*i).dim : 0; }
 
D4Maps *Array::maps() {
    if (!d_maps)
        d_maps = new D4Maps(this); // init with this as parent
    return d_maps;
}
 
#if 0
unsigned int Array::width(bool constrained) const
{
 
    if (constrained) {
        // This preserves the original method's semantics when we ask for the
        // size of the constrained array but no constraint has been applied.
        // In this case, length will be -1. Wrong, I know...
        return length() * var()->width(constrained);
    }
    else {
        int length = 1;
        for (Dim_iter i = _shape.begin(); i != _shape.end(); i++) {
            length *= dimension_size(i, false);
        }
        return length * var()->width(false);
    }
}
#endif
 
class PrintD4ArrayDimXMLWriter : public unary_function<Array::dimension &, void> {
    XMLWriter &xml;
    // Was this variable constrained using local/direct slicing? i.e., is d_local_constraint set?
    // If so, don't use shared dimensions; instead emit Dim elements that are anonymous.
    bool d_constrained;
 
public:
    PrintD4ArrayDimXMLWriter(XMLWriter &xml, bool c) : xml(xml), d_constrained(c) {}
 
    void operator()(Array::dimension &d) {
        // This duplicates code in D4Dimensions (where D4Dimension::print_dap4() is defined
        // because of the need to print the constrained size of a dimension. I think that
        // the constraint information has to be kept here and not in the dimension (since they
        // are shared dims). Could hack print_dap4() to take the constrained size, however.
        if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar *)"Dim") < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write Dim element");
 
        string name = (d.dim) ? d.dim->fully_qualified_name() : d.name;
        // If there is a name, there must be a Dimension (named dimension) in scope
        // so write its name but not its size.
        if (!d_constrained && !name.empty()) {
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"name", (const xmlChar *)name.c_str()) <
                0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
        } else if (d.use_sdim_for_slice) {
            assert(!name.empty());
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"name", (const xmlChar *)name.c_str()) <
                0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
        } else {
            ostringstream size;
            size << (d_constrained ? d.c_size : d.size);
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"size",
                                            (const xmlChar *)size.str().c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
        }
 
        if (xmlTextWriterEndElement(xml.get_writer()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not end Dim element");
    }
};
 
class PrintD4ConstructorVarXMLWriter : public unary_function<BaseType *, void> {
    XMLWriter &xml;
    bool d_constrained;
 
public:
    PrintD4ConstructorVarXMLWriter(XMLWriter &xml, bool c) : xml(xml), d_constrained(c) {}
 
    void operator()(BaseType *btp) { btp->print_dap4(xml, d_constrained); }
};
 
class PrintD4MapXMLWriter : public unary_function<D4Map *, void> {
    XMLWriter &xml;
 
public:
    PrintD4MapXMLWriter(XMLWriter &xml) : xml(xml) {}
 
    void operator()(D4Map *m) { m->print_dap4(xml); }
};

void Array::print_dap4(XMLWriter &xml, bool constrained /* default: false*/) {
    if (constrained && !send_p())
        return;
 
    if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar *)var()->type_name().c_str()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not write " + type_name() + " element");
 
    if (!name().empty())
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"name", (const xmlChar *)name().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
    // Hack job... Copied from D4Enum::print_xml_writer. jhrg 11/12/13
    if (var()->type() == dods_enum_c) {
        D4Enum *e = static_cast<D4Enum *>(var());
        string path = e->enumeration()->name();
        if (e->enumeration()->parent()) {
            // print the FQN for the enum def; D4Group::FQN() includes the trailing '/'
            path = static_cast<D4Group *>(e->enumeration()->parent()->parent())->FQN() + path;
        }
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"enum", (const xmlChar *)path.c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for enum");
    }
 
    if (prototype()->is_constructor_type()) {
        Constructor &c = static_cast<Constructor &>(*prototype());
        for_each(c.var_begin(), c.var_end(), PrintD4ConstructorVarXMLWriter(xml, constrained));
        // bind2nd(mem_fun_ref(&BaseType::print_dap4), xml));
    }
 
    // Drop the local_constraint which is per-array and use a per-dimension on instead
    for_each(dim_begin(), dim_end(), PrintD4ArrayDimXMLWriter(xml, constrained));
 
    attributes()->print_dap4(xml);
 
    for_each(maps()->map_begin(), maps()->map_end(), PrintD4MapXMLWriter(xml));
 
    if (xmlTextWriterEndElement(xml.get_writer()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not end " + type_name() + " element");
}

void Array::print_decl(FILE *out, string space, bool print_semi, bool constraint_info, bool constrained) {
    ostringstream oss;
    print_decl(oss, space, print_semi, constraint_info, constrained);
    fwrite(oss.str().data(), sizeof(char), oss.str().length(), out);
}

void Array::print_decl(ostream &out, string space, bool print_semi, bool constraint_info, bool constrained) {
    if (constrained && !send_p())
        return;
 
    // print it, but w/o semicolon
    var()->print_decl(out, space, false, constraint_info, constrained);
 
    for (Dim_citer i = _shape.begin(); i != _shape.end(); i++) {
        out << "[";
        if ((*i).name != "") {
            out << id2www((*i).name) << " = ";
        }
        if (constrained) {
            out << (*i).c_size << "]";
        } else {
            out << (*i).size << "]";
        }
    }
 
    if (print_semi) {
        out << ";\n";
    }
}

void Array::print_xml(FILE *out, string space, bool constrained) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, "Array");
    fwrite(xml.get_doc(), sizeof(char), xml.get_doc_size(), out);
}

void Array::print_xml(ostream &out, string space, bool constrained) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, "Array");
    out << xml.get_doc();
}

void Array::print_as_map_xml(FILE *out, string space, bool constrained) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, "Map");
    fwrite(xml.get_doc(), sizeof(char), xml.get_doc_size(), out);
}

void Array::print_as_map_xml(ostream &out, string space, bool constrained) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, "Map");
    out << xml.get_doc();
}

void Array::print_xml_core(FILE *out, string space, bool constrained, string tag) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, tag);
    fwrite(xml.get_doc(), sizeof(char), xml.get_doc_size(), out);
}

void Array::print_xml_core(ostream &out, string space, bool constrained, string tag) {
    XMLWriter xml(space);
    print_xml_writer_core(xml, constrained, tag);
    out << xml.get_doc();
}
 
void Array::print_xml_writer(XMLWriter &xml, bool constrained) { print_xml_writer_core(xml, constrained, "Array"); }
 
void Array::print_as_map_xml_writer(XMLWriter &xml, bool constrained) {
    print_xml_writer_core(xml, constrained, "Map");
}
 
class PrintArrayDimXMLWriter : public unary_function<Array::dimension &, void> {
    XMLWriter &xml;
    bool d_constrained;
 
public:
    PrintArrayDimXMLWriter(XMLWriter &xml, bool c) : xml(xml), d_constrained(c) {}
 
    void operator()(Array::dimension &d) {
        if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar *)"dimension") < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write dimension element");
 
        if (!d.name.empty())
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"name",
                                            (const xmlChar *)d.name.c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
        ostringstream size;
        size << (d_constrained ? d.c_size : d.size);
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"size",
                                        (const xmlChar *)size.str().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
        if (xmlTextWriterEndElement(xml.get_writer()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not end dimension element");
    }
};
 
void Array::print_xml_writer_core(XMLWriter &xml, bool constrained, string tag) {
    if (constrained && !send_p())
        return;
 
    if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar *)tag.c_str()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not write " + tag + " element");
 
    if (!name().empty())
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar *)"name", (const xmlChar *)name().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
    get_attr_table().print_xml_writer(xml);
 
    BaseType *btp = var();
    string tmp_name = btp->name();
    btp->set_name("");
    btp->print_xml_writer(xml, constrained);
    btp->set_name(tmp_name);
 
    for_each(dim_begin(), dim_end(), PrintArrayDimXMLWriter(xml, constrained));
 
    if (xmlTextWriterEndElement(xml.get_writer()) < 0)
        throw InternalErr(__FILE__, __LINE__, "Could not end " + tag + " element");
}

uint64_t Array::print_array(FILE *out, uint64_t index, unsigned int dims, uint64_t shape[]) {
    ostringstream oss;
    uint64_t i = print_array(oss, index, dims, shape);
    fwrite(oss.str().data(), sizeof(char), oss.str().length(), out);
 
    return i;
}

uint64_t Array::print_array(ostream &out, uint64_t index, unsigned int dims, uint64_t shape[]) {
    if (dims == 1) {
        out << "{";
 
        // Added test in case this method is passed an array with no elements. jhrg 1/27/16
        if (shape[0] >= 1) {
            for (uint64_t i = 0; i < shape[0] - 1; ++i) {
                var_ll(index++)->print_val(out, "", false);
                out << ", ";
            }
            var_ll(index++)->print_val(out, "", false);
        }
 
        out << "}";
 
        return index;
    } else {
        out << "{";
        // Fixed an off-by-one error in the following loop. Since the array
        // length is shape[dims-1]-1 *and* since we want one less dimension
        // than that, the correct limit on this loop is shape[dims-2]-1. From
        // Todd Karakasian.
        //
        // The saga continues; the loop test should be `i < shape[0]-1'. jhrg
        // 9/12/96.
        //
        // For arrays that hold zero values but have rank > 1, the print out
        // may look a little odd (e.g., x[4][0] will print as { {}, {}, {}, {} })
        // but it's not wrong and this is really for debugging mostly. jhrg 1/28/16
        if (shape[0] > 0) {
            for (uint64_t i = 0; i < shape[0] - 1; ++i) {
                index = print_array(out, index, dims - 1, shape + 1);
                out << ",";
            }
 
            index = print_array(out, index, dims - 1, shape + 1);
        }
 
        out << "}";
 
        return index;
    }
}
 
void Array::print_val(FILE *out, string space, bool print_decl_p) {
    ostringstream oss;
    print_val(oss, space, print_decl_p);
    fwrite(oss.str().data(), sizeof(char), oss.str().length(), out);
}
 
void Array::print_val(ostream &out, string space, bool print_decl_p) {
    // print the declaration if print decl is true.
    // for each dimension,
    //   for each element,
    //     print the array given its shape, number of dimensions.
    // Add the `;'
 
    if (print_decl_p) {
        print_decl(out, space, false, false, false);
        out << " = ";
    }
 
    auto shape = new uint64_t[dimensions(true)];
    unsigned int index = 0;
    for (Dim_iter i = _shape.begin(); i != _shape.end() && index < dimensions(true); ++i)
        shape[index++] = dimension_size_ll(i, true);
 
    print_array(out, 0, dimensions(true), shape);
 
    delete[] shape;
    shape = 0;
 
    if (print_decl_p) {
        out << ";\n";
    }
}

 
bool Array::check_semantics(string &msg, bool) {
    bool sem = BaseType::check_semantics(msg) && !_shape.empty();
 
    if (!sem)
        msg = "An array variable must have dimensions";
 
    return sem;
}

string get_dims_decl(Array &a) {
    stringstream sqr_brkty_stuff;
    for (auto itr = a.dim_begin(); itr != a.dim_end(); itr++) {
        sqr_brkty_stuff << "[";
        string dim_name = a.dimension_name(itr);
        if (!dim_name.empty()) {
            sqr_brkty_stuff << dim_name << "=";
        }
        sqr_brkty_stuff << a.dimension_size_ll(itr, true) << "]";
    }
    return sqr_brkty_stuff.str();
}

bool Array::is_dap4_projected(std::vector<std::string> &inventory) {
    bool has_projected_dap4 = false;
    if (send_p()) {
        if (prototype()->is_constructor_type()) {
            has_projected_dap4 =
                prototype()->is_dap4_projected(inventory) || attributes()->has_dap4_types(FQN(), inventory);
        } else {
            Type type = prototype()->type();
            has_projected_dap4 = (type == libdap::dods_int8_c) || (type == dods_uint64_c) || (type == dods_int64_c);
            if (has_projected_dap4) {
                inventory.emplace_back(prototype()->type_name() + " " + FQN() + get_dims_decl(*this));
            }
            has_projected_dap4 |= attributes()->has_dap4_types(FQN(), inventory);
        }
    }
    return has_projected_dap4;
}

void Array::dump(ostream &strm) const {
    strm << DapIndent::LMarg << "Array::dump - (" << (void *)this << ")" << endl;
    DapIndent::Indent();
    Vector::dump(strm);
    strm << DapIndent::LMarg << "shape:" << endl;
    DapIndent::Indent();
    Dim_citer i = _shape.begin();
    Dim_citer ie = _shape.end();
    unsigned int dim_num = 0;
    for (; i != ie; i++) {
        strm << DapIndent::LMarg << "dimension " << dim_num++ << ":" << endl;
        DapIndent::Indent();
        strm << DapIndent::LMarg << "name: " << (*i).name << endl;
        strm << DapIndent::LMarg << "size: " << (*i).size << endl;
        strm << DapIndent::LMarg << "start: " << (*i).start << endl;
        strm << DapIndent::LMarg << "stop: " << (*i).stop << endl;
        strm << DapIndent::LMarg << "stride: " << (*i).stride << endl;
        strm << DapIndent::LMarg << "constrained size: " << (*i).c_size << endl;
        DapIndent::UnIndent();
    }
    DapIndent::UnIndent();
    DapIndent::UnIndent();
}

void Array::set_var_storage_info(const var_storage_info &my_vs_info) {
 
    vs_info.filter = my_vs_info.filter;
 
    for (const auto &def_lev : my_vs_info.deflate_levels)
        vs_info.deflate_levels.push_back(def_lev);
 
    for (const auto &chunk_dim : my_vs_info.chunk_dims)
        vs_info.chunk_dims.push_back(chunk_dim);
 
    for (const auto &vci : my_vs_info.var_chunk_info) {
        var_chunk_info_t vci_t;
        vci_t.filter_mask = vci.filter_mask;
        vci_t.chunk_direct_io_offset = vci.chunk_direct_io_offset;
        vci_t.chunk_buffer_size = vci.chunk_buffer_size;
        for (const auto &chunk_coord : vci.chunk_coords)
            vci_t.chunk_coords.push_back(chunk_coord);
        vs_info.var_chunk_info.push_back(vci_t);
    }
}
 
} // namespace libdap