DMRpp.cc

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of the BES
 
// Copyright (c) 2016 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.
 
#include "config.h"
 
#include <sstream>
#include <vector>
 
#include <libdap/DDS.h>
#include <libdap/XMLWriter.h>
#include <libdap/D4Group.h>
#include <libdap/D4BaseTypeFactory.h>
#include <libdap/InternalErr.h>
 
#include "DMRpp.h"
#include "DmrppCommon.h"
#include "DmrppTypeFactory.h"
 
using namespace libdap;
using namespace std;
 
namespace dmrpp {
 
DMRpp::DMRpp(DmrppTypeFactory *factory, const std::string &name) : DMR(factory, name)
{
}

 
void DMRpp::print_dmrpp(XMLWriter &xml, const string &href, bool constrained, bool print_chunks)
{
    bool pc_initial_value = DmrppCommon::d_print_chunks;
    DmrppCommon::d_print_chunks = print_chunks;
 
    try {
        if (xmlTextWriterStartElement(xml.get_writer(), (const xmlChar*) "Dataset") < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write Dataset element");
 
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "xmlns",
            (const xmlChar*) get_namespace().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for xmlns");
 
        // The dmrpp namespace
        if (DmrppCommon::d_print_chunks)
            if (xmlTextWriterWriteAttribute(xml.get_writer(),
                (const xmlChar*)string("xmlns:").append(DmrppCommon::d_ns_prefix).c_str(),
                    (const xmlChar*)DmrppCommon::d_dmrpp_ns.c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for xmlns:dmrpp");
 
        if (!request_xml_base().empty()) {
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "xml:base",
                (const xmlChar*) request_xml_base().c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for xml:base");
        }
 
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "dapVersion",
            (const xmlChar*) dap_version().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for dapVersion");
 
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "dmrVersion",
            (const xmlChar*) dmr_version().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for dapVersion");
 
        if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*) "name", (const xmlChar*) name().c_str()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not write attribute for name");
 
        // cerr << "DMRpp::" <<__func__ << "() href: "<< href << endl;
        if (!href.empty())
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*)string(DmrppCommon::d_ns_prefix).append(":href").c_str(),
                (const xmlChar*) href.c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for href");
 
        if (!get_version().empty())
            if (xmlTextWriterWriteAttribute(xml.get_writer(), (const xmlChar*)string(DmrppCommon::d_ns_prefix).append(":version").c_str(),
                                            (const xmlChar*) get_version().c_str()) < 0)
                throw InternalErr(__FILE__, __LINE__, "Could not write attribute for version");
 
        root()->print_dap4(xml, constrained);
 
        if (xmlTextWriterEndElement(xml.get_writer()) < 0)
            throw InternalErr(__FILE__, __LINE__, "Could not end the top-level Group element");
    }
    catch (...) {
        DmrppCommon::d_print_chunks = pc_initial_value;
        throw;
    }
 
    DmrppCommon::d_print_chunks = pc_initial_value;
}

void DMRpp::print_dap4(XMLWriter &xml, bool constrained /* false */)
{
    print_dmrpp(xml, get_href(), constrained, get_print_chunks());
}
 
libdap::DDS *DMRpp::getDDS()
{
    DmrppTypeFactory factory;
    unique_ptr<DDS> dds(new DDS(&factory, name()));
    dds->filename(filename());
 
    // Now copy the global attributes
    unique_ptr<vector<BaseType *>> top_vars(root()->transform_to_dap2(&(dds->get_attr_table())/*, true*/));
    for (auto i = top_vars->begin(), e = top_vars->end(); i != e; i++) {
        dds->add_var_nocopy(*i);
    }
 
    dds->set_factory(nullptr);
    return dds.release();
}
 
} /* namespace dmrpp */