DMR.h

// -*- 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.
 
#ifndef _dmr_h
#define _dmr_h 1
 
#include <cassert>
 
#include <iostream>
#include <string>
#include <vector>
 
//#include "D4Group.h"
//#include "XMLWriter.h"
#include "DapObj.h"
 
namespace libdap
{
 
class D4Group;
class D4BaseTypeFactory;
class XMLWriter;
 
class DDS;
 
class DMR : public DapObj
{
private:
    D4BaseTypeFactory *d_factory;
 
    string d_name;
    string d_filename;
 
    int d_dap_major;
    int d_dap_minor;
    string d_dap_version;
 
    string d_dmr_version;
 
    string d_request_xml_base;
 
    string d_namespace;
 
    long d_max_response_size;
 
    D4Group *d_root;
 
    friend class DMRTest;
 
protected:
    void m_duplicate(const DMR &dmr);
 
public:
    DMR();
    DMR(const DMR &dmr);
    DMR(D4BaseTypeFactory *factory, const string &name = "");
 
    DMR(D4BaseTypeFactory *factory, DDS &dds);
 
    virtual ~DMR();
 
    DMR &operator=(const DMR &rhs);
 
    virtual void build_using_dds(DDS &dds);
 
    bool OK() const { return (d_factory && d_root && !d_dap_version.empty()); }
 
    string name() const { return d_name; }
    void set_name(const string &n) { d_name = n; }
 
    virtual D4BaseTypeFactory *factory() { return d_factory; }
    virtual void set_factory(D4BaseTypeFactory *f) { d_factory = f; }
 
    string filename() const { return d_filename; }
    void set_filename(const string &fn) { d_filename = fn;}
 
    string dap_version() const { return d_dap_version; }
    void set_dap_version(const string &version_string);
    int dap_major() const { return d_dap_major; }
    int dap_minor() const { return d_dap_minor; }
 
    string dmr_version() const { return d_dmr_version; }
    void set_dmr_version(const string &v) { d_dmr_version = v; }
 
    string request_xml_base() const { return d_request_xml_base; }
 
    void set_request_xml_base(const string &xb) { d_request_xml_base = xb; }
 
    string get_namespace() const { return d_namespace; }
 
    void set_namespace(const string &ns) { d_namespace = ns; }
 
    // TODO Move the response_limit methods to D4ResponseBuilder? jhrg 5/1/13
    long response_limit() { return d_max_response_size; }
 
    void set_response_limit(long size) { d_max_response_size = size; }
 
    long request_size(bool constrained);
 
    D4Group *root();
 
    void print_dap4(XMLWriter &xml, bool constrained = false);
 
    virtual void dump(ostream &strm) const ;
};
 
} // namespace libdap
 
#endif // _dmr_h