dialog/request.h

Go to the documentation of this file.

/*
 * request.h
 *
 * Copyright (C) 2008  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef WAVEPACKET_DIALOG_REQUEST_H__
#define WAVEPACKET_DIALOG_REQUEST_H__

// includes --------------------------------------------------------------------
#include "common/common.h"

#include <sstream>


// forward declarations
class Datahash;


namespace dialog {

/// \ingroup dialog
/*@{*/


/// object to help construct dialog request streams
///
/// It is recommended that callers use this object instead of directly creating
/// text streams!  This way your code is relatively insulated if elements add
/// new attributes, etc.  The code is also easier to write and maintain.
///
/// Typical usage is to create a ContainerRequest, add a bunch of stuff, and
/// then call get() to retrieve the string that represents the dialog stream.
///
/// Once you call get(), the ContainerRequest is considered closed.  Any
/// additional attempts to add data to the container is a programming failure
/// and the program will hard stop.
///
/// If you want to recursively add subcontainers (nested elements within the
/// dialog), create separate ContainerRequest objects for each child container
/// and add them to the parent container with addContainer().  Note that adding
/// a ContainerRequest to a parent has the side-effect of closing the child
/// container.
class ContainerRequest {
public:
        // public typedefs -----------------------------------------------------
        enum eAxis {
                        eAxis_Horizontal        = 1,
                        eAxis_Vertical          = 2
                };

        // constructor ---------------------------------------------------------
        ContainerRequest(eAxis axis = eAxis_Vertical) : m_closed(false) {
                        m_stream << "type container\n";
                        m_stream << "axis ";
                        m_stream << ((eAxis_Horizontal == axis) ? "h" : "v");
                        m_stream << "\n";
                }

        // accessors -----------------------------------------------------------
        std::string get(void) {
                        this->close();
                        return m_stream.str();
                }

        smart_ptr<Datahash> getDatahash(void); 

        void addLabel(IN const char * label) {
                        ASSERT(!m_closed, "request is closed");
                        ASSERT(label, "null");
                        m_stream << "element {\n";
                        m_stream << "type label\n";
                        m_stream << "value " << label << "\n";
                        m_stream << "}\n";
                }

        void addWidthString(IN const char * widthString) {
                        ASSERT(!m_closed, "request is closed");
                        ASSERT(widthString, "null");
                        m_stream << "widthString " << widthString << "\n";
                }

        void addButton(IN const char * submit, IN const char * label) {
                        ASSERT(!m_closed, "request is closed");
                        ASSERT(submit, "null");
                        ASSERT(label, "null");
                        m_stream << "element {\n";
                        m_stream << "type button\n";
                        m_stream << "submit " << submit << "\n";
                        m_stream << "label " << label << "\n";
                        m_stream << "}\n";
                }

        void addTextbox(IN const char * name, IN const char * value,
                                IN int max, IN bool encrypted = false) {
                        ASSERT(!m_closed, "request is closed");
                        ASSERT(name, "null");
                        ASSERT(value, "null");
                        ASSERT(max > 0, "Bad textbox max: %d", max);
                        m_stream << "element {\n";
                        m_stream << "type textbox\n";
                        m_stream << "name " << name << "\n";
                        m_stream << "value " << value << "\n";
                        m_stream << "max " << max << "\n";
                        if (encrypted) {
                                m_stream << "encrypt true\n";
                        }
                        m_stream << "}\n";
                }

        void addContainer(IN ContainerRequest& cr) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << "element {\n";
                        m_stream << cr.get();
                        m_stream << "}\n";
                }

        /// raw access to stream!
        void addCustom(IN const char * string) {
                        ASSERT(!m_closed, "request is closed");
                        m_stream << string << "\n";
                }
private:
        // private helper methods ----------------------------------------------
        void close(void) {
                        if (!m_closed) {
                                m_closed = true;
                        }
                }

        // private member data -------------------------------------------------
        bool                    m_closed;
        std::ostringstream      m_stream;
};



};      // dialog namespace

#endif  // WAVEPACKET_DIALOG_REQUEST_H__