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 "DMR.h"
#include "D4Dimensions.h"
#include "D4Maps.h"
#include "D4Group.h"
#include "D4EnumDefs.h"
#include "D4Enum.h"
#include "XMLWriter.h"

#include "util.h"
#include "debug.h"
#include "InternalErr.h"
#include "escaping.h"
#include "DapIndent.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));
    }
    else {
        d_maps = 0;
    }
    // d_maps = a.d_maps ? new D4Maps(*(a.d_maps)) : 0;
}

// The first method of calculating length works when only one dimension is
// constrained and you want the others to appear in 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)
{
    int length = 1;
    for (Dim_citer i = _shape.begin(); i != _shape.end(); i++) {
#if 0
        // If the size of any dimension is zero, then the array is not
        // capable of storing any values. jhrg 1/28/16
        length *= (*i).c_size > 0 ? (*i).c_size : 1;
#endif
        length *= (*i).c_size;
    }

    set_length(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, 0, dods_array_c, is_dap4), d_maps(0)
{
    add_var(v); // Vector::add_var() stores null if v is null
}

Array::Array(const string &n, const string &d, BaseType *v, bool is_dap4 /* default:false */) :
    Vector(n, d, 0, dods_array_c, is_dap4), d_maps(0)
{
    add_var(v); // Vector::add_var() stores null if v is null
}

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;

    dynamic_cast<Vector &>(*this) = 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 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);
    DBG(cerr << __func__ << "() - END (array:" << name() << ")" << endl);;
}

bool Array::is_dap2_grid()
{
    bool is_grid = false;
    if (this->is_dap4()) {
        DBG( cerr << __func__ << "() - Array '"<< name() << "' is DAP4 object!" << endl);
        D4Maps *d4_maps = this->maps();
        is_grid = d4_maps->size(); // It can't be a grid if there are no maps...
        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()->_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());
            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.
            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());
                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.");

                        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(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;

// 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;

    if (dim->constrained()) add_constraint(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)
            size = (*i).c_size;
        else
            size = (*i).size;
    }

    return size;
}

int Array::dimension_start(Dim_iter i, bool /*constrained*/)
{
    return (!_shape.empty()) ? (*i).start : 0;
}

int Array::dimension_stop(Dim_iter i, bool /*constrained*/)
{
    return (!_shape.empty()) ? (*i).stop : 0;
}

int Array::dimension_stride(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");
}

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

    return i;
}

unsigned int Array::print_array(ostream &out, unsigned int index, unsigned int dims, unsigned int 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 (unsigned i = 0; i < shape[0] - 1; ++i) {
                var(index++)->print_val(out, "", false);
                out << ", ";
            }
            var(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 (unsigned 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 << " = ";
    }

    unsigned int *shape = new unsigned int[dimensions(true)];
    unsigned int index = 0;
    for (Dim_iter i = _shape.begin(); i != _shape.end() && index < dimensions(true); ++i)
        shape[index++] = dimension_size(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;
}

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();
}

} // namespace libdap