BESDapResponseBuilder.h

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2011 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.
 
#ifndef _response_builder_h
#define _response_builder_h
 
#include <string>
#include <memory>
 
#define DAP_PROTOCOL_VERSION "3.2"
 
#undef DAP2_STORED_RESULTS
 
class BESDapFunctionResponseCache;
 
class BESDataHandlerInterface;
 
class BESResponseObject;
 
class BRDRequestHandler;
 
namespace libdap {
class ConstraintEvaluator;
 
class DDS;
 
class DAS;
 
class DMR;
 
class D4Group;
}
 

 
class BESDapResponseBuilder {
public:
    friend class ResponseBuilderTest;
 
protected:
    std::string d_dataset;          
    std::string d_dap2ce;           
    std::string d_dap4ce;           
    std::string d_dap4function;     
    std::string d_btp_func_ce;      
    std::string d_default_protocol;    

    std::string d_async_accepted;

    std::string d_store_result;
 
#ifdef DAP2_STORED_RESULTS
    bool store_dap2_result(ostream &out, libdap::DDS &dds, libdap::ConstraintEvaluator &eval);
#endif
 
    void send_dap4_data_using_ce(std::ostream &out, libdap::DMR &dmr, bool with_mime_headersr);
 
    void intern_dap4_data_grp(libdap::D4Group *grp);
 
public:

    BESDapResponseBuilder() : d_dataset(""), d_dap2ce(""), d_dap4ce(""), d_dap4function(""),
                              d_btp_func_ce(""), d_default_protocol(DAP_PROTOCOL_VERSION),
                              d_async_accepted(""), d_store_result("") {};
 
    virtual ~BESDapResponseBuilder();
 
    virtual std::string get_ce() const;
 
    virtual void set_ce(std::string _ce);
 
    virtual std::string get_dap4ce() const;
 
    virtual void set_dap4ce(const std::string &_ce);
 
    virtual std::string get_dap4function() const;
 
    virtual void set_dap4function(const std::string &_func);
 
    virtual std::string get_store_result() const;
 
    virtual void set_store_result(const std::string &_sr);
 
    virtual std::string get_async_accepted() const;
 
    virtual void set_async_accepted(const std::string &_aa);
 
    virtual std::string get_btp_func_ce() const {
        return d_btp_func_ce;
    }
 
    virtual void set_btp_func_ce(const std::string &_ce) {
        d_btp_func_ce = _ce;
    }
 
    virtual std::string get_dataset_name() const;
 
    virtual void set_dataset_name(const std::string &_dataset);
 
    virtual void split_ce(libdap::ConstraintEvaluator &eval, const std::string &expr = "");
 
    virtual void send_das(std::ostream &out, libdap::DAS &das, bool with_mime_headers = true) const;
 
    virtual void send_das(std::ostream &out, libdap::DDS **dds, libdap::ConstraintEvaluator &eval, bool constrained =
    false, bool with_mime_headers = true);
 
    virtual void send_dds(std::ostream &out, libdap::DDS **dds, libdap::ConstraintEvaluator &eval, bool constrained =
    false, bool with_mime_headers = true);
 
    virtual void serialize_dap2_data_dds(std::ostream &out, libdap::DDS **dds, libdap::ConstraintEvaluator &eval,
                                         bool ce_eval = true);
 
    virtual void send_dap2_data(std::ostream &data_stream, libdap::DDS **dds, libdap::ConstraintEvaluator &eval,
                                bool with_mime_headers = true);
 
    virtual void send_dap2_data(BESDataHandlerInterface &dhi, libdap::DDS **dds, libdap::ConstraintEvaluator &eval,
                                bool with_mime_headers = true);
 
    // Added jhrg 9/1/16
    virtual libdap::DDS *intern_dap2_data(BESResponseObject *obj, BESDataHandlerInterface &dhi);
 
    virtual libdap::DDS *process_dap2_dds(BESResponseObject *obj, BESDataHandlerInterface &dhi);
 
    // Add the handling of DMR objects, including the function to handle expression constraints.
    // May need to improve. 5/13/20
    virtual libdap::DMR *intern_dap4_data(BESResponseObject *obj, BESDataHandlerInterface &dhi);
 
    virtual libdap::DMR *process_dap4_dmr(BESResponseObject *obj, BESDataHandlerInterface &dhi);
 
    virtual void dap4_process_ce_for_intern_data(libdap::DMR &dmr);
 
    virtual void send_ddx(std::ostream &out, libdap::DDS **dds, libdap::ConstraintEvaluator &eval,
                          bool with_mime_headers = true);
 
#ifdef    DAP2_STORED_RESULTS
    virtual void serialize_dap2_data_ddx(std::ostream &out, libdap::DDS **dds, libdap::ConstraintEvaluator & eval,
            const std::string &boundary, const std::string &start, bool ce_eval = true);
#endif
 
    virtual void send_dmr(std::ostream &out, libdap::DMR &dmr, bool with_mime_headers = true);
 
    virtual void send_dap4_data(std::ostream &out, libdap::DMR &dmr, bool with_mime_headers = true);
 
    virtual void serialize_dap4_data(std::ostream &out, libdap::DMR &dmr, bool with_mime_headers = true);
 
    virtual bool store_dap4_result(std::ostream &out, libdap::DMR &dmr);
 
    std::unique_ptr<libdap::DMR> setup_dap4_intern_data(BESResponseObject *obj, BESDataHandlerInterface &dhi);
};
 
 
#endif // _response_builder_h