BESDapResponseBuilder.h

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) 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>

class BESDapResponseCache;

namespace libdap {
    class ConstraintEvaluator;
    class DDS;
    class DAS;
}

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;      
        int d_timeout;                  
        std::string d_default_protocol; 

        std::string d_async_accepted;

        std::string d_store_result;


        BESDapResponseCache *d_response_cache;

        void initialize();
        bool store_dap2_result(ostream &out, libdap::DDS &dds, libdap::ConstraintEvaluator &eval);

        void send_dap4_data_using_ce(std::ostream &out, libdap::DMR &dmr, bool with_mime_headersr);

public:

        BESDapResponseBuilder()
        {
                initialize();
        }

        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(std::string _ce);

        virtual std::string get_dap4function() const;
        virtual void set_dap4function(std::string _func);

        virtual std::string get_store_result() const;
        virtual void set_store_result(std::string _sr);

        virtual std::string get_async_accepted() const;
        virtual void set_async_accepted(std::string _aa);

        virtual std::string get_btp_func_ce() const
        {
                return d_btp_func_ce;
        }
        virtual void set_btp_func_ce(std::string _ce)
        {
                d_btp_func_ce = _ce;
        }

        virtual std::string get_dataset_name() const;
        virtual void set_dataset_name(const std::string _dataset);

        void set_timeout(int timeout = 0);
        int get_timeout() const;

        virtual void establish_timeout(std::ostream &stream) const;
        virtual void remove_timeout() const;

        virtual void split_ce(libdap::ConstraintEvaluator &eval, const std::string &expr = "");

        virtual BESDapResponseCache *responseCache();

        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_ddx(std::ostream &out, libdap::DDS &dds, libdap::ConstraintEvaluator &eval,
                        bool with_mime_headers = true);

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

        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(ostream &out, libdap::DMR &dmr);
};

#endif // _response_builder_h