D4Sequence.cc

Go to the documentation of this file.

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2013 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#include "config.h"
 
#include <algorithm>
#include <sstream>
#include <string>
 
#include "D4Sequence.h"
 
#include "D4StreamMarshaller.h"
#include "D4StreamUnMarshaller.h"
 
#include "D4FilterClause.h" // also contains D4FilterClauseList
#include "D4RValue.h"
 
#include "DapIndent.h"
#include "Error.h"
#include "InternalErr.h"
#include "debug.h"
#include "escaping.h"
#include "util.h"
 
#undef CLEAR_LOCAL_DATA
 
using namespace std;
 
namespace libdap {
 
// Private member functions
 
// A reminder of these type defs
//
// typedef vector<BaseType *> D4SeqRow;
// typedef vector<D4SeqRow *> D4SeqValues;
// D4SeqValues d_values;
 
void D4Sequence::m_duplicate(const D4Sequence &s) {
    d_length = s.d_length;
#if INDEX_SUBSETTING
    d_starting_row_number = s.d_starting_row_number;
    d_ending_row_number = s.d_ending_row_number;
    d_row_stride = s.d_row_stride;
#endif
    // Deep copy for the values
    for (const auto &row :
         s.d_values) { // D4SeqValues::const_iterator i = s.d_values.begin(), e = s.d_values.end(); i != e; ++i) {
        // D4SeqRow &row = **i;
        auto dest = make_unique<D4SeqRow>();
        for (const auto &basetype : *row) { // D4SeqRow::const_iterator j = row.begin(), e = row.end(); j != e; ++j) {
            // *j is a BaseType*
            dest->push_back(basetype->ptr_duplicate());
        }
 
        d_values.push_back(dest.release());
    }
 
    d_copy_clauses = s.d_copy_clauses;
    d_clauses = (s.d_clauses != nullptr) ? new D4FilterClauseList(*s.d_clauses) : nullptr; // deep copy if != 0
}
 
// Public member functions

D4Sequence::D4Sequence(const string &n)
    : Constructor(n, dods_sequence_c, true /* is dap4 */), d_clauses(0), d_copy_clauses(true), d_length(0) {}

D4Sequence::D4Sequence(const string &n, const string &d)
    : Constructor(n, d, dods_sequence_c, true /* is dap4 */), d_clauses(0), d_copy_clauses(true), d_length(0) {}

D4Sequence::D4Sequence(const D4Sequence &rhs) : Constructor(rhs) { m_duplicate(rhs); }
 
BaseType *D4Sequence::ptr_duplicate() { return new D4Sequence(*this); }
 
static inline void delete_bt(BaseType *bt_ptr) { delete bt_ptr; }
 
static inline void delete_rows(D4SeqRow *bt_row_ptr) {
    for_each(bt_row_ptr->begin(), bt_row_ptr->end(), delete_bt);
 
    delete bt_row_ptr;
}
 
D4Sequence::~D4Sequence() {
    clear_local_data();
    delete d_clauses;
}
 
void D4Sequence::clear_local_data() {
    if (!d_values.empty()) {
        for_each(d_values.begin(), d_values.end(), delete_rows);
        d_values.resize(0);
    }
 
    set_read_p(false);
}
 
D4Sequence &D4Sequence::operator=(const D4Sequence &rhs) {
    if (this == &rhs)
        return *this;
    Constructor::operator=(rhs);
    m_duplicate(rhs);
    return *this;
}

bool D4Sequence::read_next_instance(bool filter) {
    bool eof = false;
    bool done = false;
 
    do {
        eof = read();
        if (eof) { // bail if EOF
            continue;
        }
        // if we are supposed to filter and the clauses eval to true, we're done
        else if (filter && d_clauses && d_clauses->value()) {
            d_length++;
            done = true;
        }
        // else if we're not supposed to filter or there are no clauses, we're done
        else if (!filter || !d_clauses) {
            d_length++;
            done = true;
        }
 
        // Set up the next call to get another row's worth of data
        set_read_p(false);
 
    } while (!eof && !done);
 
    return !eof;
}
 
void D4Sequence::intern_data() { read_sequence_values(true); }

void D4Sequence::read_sequence_values(bool filter) {
    DBG(cerr << __PRETTY_FUNCTION__ << " BEGIN" << endl);
 
    if (read_p())
        return;
 
    // Read the data values, then serialize. NB: read_next_instance sets d_length
    // evaluates the filter expression
    while (read_next_instance(filter)) {
        DBG(cerr << "read_sequence_values() - Adding row" << endl);
        auto row = make_unique<D4SeqRow>();
        for (auto &var : d_vars) { // Vars_iter i = d_vars.begin(), e = d_vars.end(); i != e; i++) {
            if (var->send_p()) {
                DBG(cerr << ":serialize() - reading data for " << (*i)->type_name() << " " << (*i)->name() << endl);
                if (var->type() == dods_sequence_c) {
                    DBG(cerr << "Reading child sequence values for " << (*i)->name() << endl);
                    const auto d4s = static_cast<D4Sequence *>(var);
                    d4s->read_sequence_values(filter);
                    d4s->d_copy_clauses = false;
                    row->push_back(d4s->ptr_duplicate());
                    d4s->d_copy_clauses = true; // Must be sure to not break the object in general
                    row->back()->set_read_p(true);
                } else {
                    // store the variable's value.
                    row->push_back(var->ptr_duplicate());
                    // the copy should have read_p true to prevent the serialize() call
                    // below in the nested for loops from triggering a second call to
                    // read().
                    row->back()->set_read_p(true);
                }
            }
        }
 
        // When specializing this, use set_value()
        d_values.push_back(row.release());
        DBG(cerr << " read_sequence_values() - Row completed" << endl);
    }
 
    set_length(d_values.size());
 
    DBGN(cerr << __PRETTY_FUNCTION__ << " END added " << d_values.size() << endl);
}

void D4Sequence::serialize(D4StreamMarshaller &m, DMR &dmr, bool filter) {
    DBGN(cerr << __PRETTY_FUNCTION__ << " BEGIN" << endl);
 
    // Read the data values, then serialize. NB: read_next_instance sets d_length
    // evaluates the filter expression
    read_sequence_values(filter);
 
    // write D4Sequence::length(); don't include the length in the checksum
    m.put_count(d_length);
 
    // By this point the d_values object holds all and only the values to be sent;
    // use the serialize methods to send them (but no need to test send_p).
    for (auto const &row : d_values) {
        for (auto &var : *row) {
            var->serialize(m, dmr, /*eval,*/ filter);
        }
    }
 
    DBGN(cerr << __PRETTY_FUNCTION__ << " END" << endl);
}
 
void D4Sequence::deserialize(D4StreamUnMarshaller &um, DMR &dmr) {
    const int64_t um_count = um.get_count();
 
    set_length(um_count);
 
    for (int64_t i = 0; i < d_length; ++i) {
        auto row = make_unique<D4SeqRow>();
        for (const auto &var : d_vars) {
            var->deserialize(um, dmr);
            row->push_back(var->ptr_duplicate());
        }
        d_values.push_back(row.release());
    }
}

D4FilterClauseList &D4Sequence::clauses() {
    if (!d_clauses)
        d_clauses = new D4FilterClauseList();
    return *d_clauses;
}
 
#if INDEX_SUBSETTING
virtual void set_row_number_constraint(int start, int stop, int stride) {
    if (stop < start)
        throw Error(malformed_expr, "Starting row number must precede the ending row number.");
 
    d_starting_row_number = start;
    d_row_stride = stride;
    d_ending_row_number = stop;
}
#endif

D4SeqRow *D4Sequence::row_value(size_t row) {
    if (row >= d_values.size())
        return nullptr;
    return d_values[row];
}

BaseType *D4Sequence::var_value(size_t row_num, const string &name) {
    D4SeqRow *row = row_value(row_num);
    if (!row)
        return nullptr;
 
    auto elem = find_if(row->begin(), row->end(), [name](const BaseType *btp) { return btp->name() == name; });
 
    return (elem != row->end()) ? *elem : nullptr;
}

BaseType *D4Sequence::var_value(size_t row_num, size_t i) {
    const D4SeqRow *row = row_value(row_num);
    if (!row)
        return nullptr;
 
    if (i >= row->size())
        return nullptr;
 
    return (*row)[i];
}
 
void D4Sequence::print_one_row(ostream &out, int row, string space, bool print_row_num) {
    if (print_row_num)
        out << "\n" << space << row << ": ";
 
    out << "{ ";
 
    const int elements = element_count();
    int j = 0;
    BaseType *bt_ptr = 0;
 
    // This version of print_one_row() works for both data read with
    // deserialize(), where each variable is assumed to have valid data, and
    // intern_data(), where some/many variables do not. Because of that, it's
    // not correct to assume that all the elements will be printed, which
    // is what the old code did.
 
    // Print the first value
    while (j < elements && !bt_ptr) {
        bt_ptr = var_value(row, j++);
        if (bt_ptr) { // data
            if (bt_ptr->type() == dods_sequence_c)
                static_cast<D4Sequence *>(bt_ptr)->print_val_by_rows(out, space + "    ", false, print_row_num);
            else
                bt_ptr->print_val(out, space, false);
        }
    }
 
    // Print the remaining values
    while (j < elements) {
        bt_ptr = var_value(row, j++);
        if (bt_ptr) { // data
            out << ", ";
            if (bt_ptr->type() == dods_sequence_c)
                static_cast<D4Sequence *>(bt_ptr)->print_val_by_rows(out, space + "    ", false, print_row_num);
            else
                bt_ptr->print_val(out, space, false);
        }
    }
 
    out << " }";
}
 
void D4Sequence::print_val_by_rows(ostream &out, string space, bool print_decl_p, bool print_row_numbers) {
    if (print_decl_p) {
        print_decl(out, space, false);
        out << " = ";
    }
 
    out << "{ ";
 
    if (length() != 0) {
        int rows = length() - 1; // -1 because the last row is treated specially
        for (int i = 0; i < rows; ++i) {
            print_one_row(out, i, space, print_row_numbers);
            out << ", ";
        }
        print_one_row(out, rows, space, print_row_numbers);
    }
 
    out << " }";
 
    if (print_decl_p)
        out << ";\n";
}
 
void D4Sequence::print_val(ostream &out, string space, bool print_decl_p) {
    DBG(cerr << name() << " isa " << type_name() << endl);
 
    print_val_by_rows(out, space, print_decl_p, false);
}

void D4Sequence::dump(ostream &strm) const {
    strm << DapIndent::LMarg << "Sequence::dump - (" << (void *)this << ")" << endl;
    DapIndent::Indent();
    Constructor::dump(strm);
    strm << DapIndent::LMarg << "# rows deserialized: " << d_length << endl;
    strm << DapIndent::LMarg << "bracket notation information:" << endl;
 
    DapIndent::Indent();
#if INDEX_SUBSETTING
    strm << DapIndent::LMarg << "starting row #: " << d_starting_row_number << endl;
    strm << DapIndent::LMarg << "row stride: " << d_row_stride << endl;
    strm << DapIndent::LMarg << "ending row #: " << d_ending_row_number << endl;
#endif
    DapIndent::UnIndent();
 
    DapIndent::UnIndent();
}
 
} // namespace libdap