osbxml.h

Go to the documentation of this file.

// OSB library ************************************************ -*- C++ -*-
/*
  AUTHOR(S): Ramlan Rusdijanto (rr)

  RCS information
   $Name: OSB_060808 $
   $Revision: 1.21 $

  License
   OSB rating and billing library for communication networks
   Copyright (C) 2004, 2005, 2006  OSB systems

   This file may be distributed and/or modify under the terms of the
   GNU General Public License (GPL) as published by the Free Software
   Foundation which is provided in the file LICENSE.GPL included in the
   packaging of this file.

   The file 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 General Public License
   for more details.

   Holders of a OSB Commercial License may use this file under the terms
   and conditions of this commercial license.
 */
#ifndef _OSBXML_H_
#define _OSBXML_H_

// *********************************************************************
// included header files
// + standard includes
#include <string>
#include <iosfwd>
#include <stack>

// + local includes
#include "osberror.h"

// *********************************************************************
// namespace extensions
namespace OSB_LIB {
    class OsbXml {
    public:
        // Args: output destination
        OsbXml(std::ostream&);
        // Args: output destination, root element name
        OsbXml(std::ostream&, std::string);
        // Args: output destination, root element name, indentation
        OsbXml(std::ostream&, std::string, std::string);

        ~OsbXml() { endRoot(); }

        // ToDo: It should be possible to have more than one attribute

        // Arg: element name
        void addElement(std::string);

        // Args: element name, element value
        template <typename T>
          void addElement(std::string, const T&);

        // Args: element name, attribute name, attribute value
        template <typename T>
          void addElement(std::string, std::string, const T&);

        // Args: element name, element value,
        //       attribute name, attribute value
        template <typename T1, typename T2>
          void addElement(std::string, const T1&, std::string, const T2&);

        // Arg: root element name
        void addRoot(std::string);

        // Args: root element name, attribute name, attribute value
        template <typename T>
          void addRoot(std::string, std::string, const T&);

        // Arg: element name
        void addChild(std::string);

        // Args: element name, attribute name, attribute value
        template <typename T>
          void addChild(std::string, std::string, const T&);

        void endChild();
        void endRoot();
        void addComment(std::string comment);

        void setIndent(std::string newIndent);

    private:
        std::stack<std::string> stack_;
        bool rootCreated_;
        std::ostream& xml_;

        std::string indent_;            // Indentation string
        std::string currIndent_;        // Indentation string repeated
        int indentLevel_;               // Current indentation level

    };

// *********************************************************************
// inline and template definitions

    inline void OsbXml::addElement(std::string name)
    {
        if (!rootCreated_) throw DefException(28) << name;
        xml_ << currIndent_;
        xml_ << "<" << name << "/>\n";
    }

    template <typename T>
      void OsbXml::addElement(std::string name, const T& value)
    {
        if (!rootCreated_) throw DefException(28) << name;
        xml_ << currIndent_;
        xml_ << "<" << name << ">" << value << "</" << name << ">\n";
    }

    template <typename T>
      void OsbXml::addElement(std::string name, std::string attrName,
                      const T& attrValue)
    {
        if (!rootCreated_) throw DefException(28) << name;
        xml_ << currIndent_;
        xml_ << "<" << name << " " << attrName << "=\""
             << attrValue << "\"/>\n";
    }

    template <typename T1, typename T2>
      void OsbXml::addElement(std::string name, const T1& value,
                              std::string attrName, const T2& attrValue)
    {
        if (!rootCreated_) throw DefException(28) << name;
        xml_ << currIndent_;
        xml_ << "<" << name << " " << attrName << "=\""
             << attrValue << "\">" << value << "</" << name << ">\n";
    }

    inline void OsbXml::addChild(std::string name)
    {
        xml_ << currIndent_;
        xml_ << "<" << name << ">\n";
        stack_.push(name);
        currIndent_ += indent_;
        ++indentLevel_;
        rootCreated_ = true;
    }

    template <typename T>
      void OsbXml::addChild(std::string name,
                            std::string attrName, const T& attrValue)
    {
        xml_ << currIndent_;
        xml_ << "<" << name << " " << attrName << "=\""
             << attrValue << "\">\n";
        stack_.push(name);
        currIndent_ += indent_;
        ++indentLevel_;
        rootCreated_ = true;
    }

    inline void OsbXml::addRoot(std::string name)
    {
        if (rootCreated_) throw DefException(37) << name;
        addChild(name);
    }

    template <typename T>
      void OsbXml::addRoot(std::string name,
                           std::string attrName, const T& attrValue)
    {
        if (rootCreated_) throw DefException(37) << name;
        addChild(name, attrName, attrValue);
    }

}                                       // namespace OSB_LIB
#endif                                  // #ifndef _OSBXML_H_

---