text: /*
   *  Created by Phil on 09/12/2010.
   *  Copyright 2010 Two Blue Cubes Ltd. All rights reserved.
   *
   *  Distributed under the Boost Software License, Version 1.0. (See accompanying
   *  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   */
  #ifndef TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
  #define TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
  
  #include "../internal/catch_stream.h"
  
  #include <sstream>
  #include <string>
  #include <vector>
  
  namespace Catch {
  
      class XmlWriter {
      public:
  
          class ScopedElement {
          public:
              ScopedElement( XmlWriter* writer )
              :   m_writer( writer )
              {}
  
              ScopedElement( ScopedElement const& other )
              :   m_writer( other.m_writer ){
                  other.m_writer = NULL;
              }
  
              ~ScopedElement() {
                  if( m_writer )
                      m_writer->endElement();
              }
  
              ScopedElement& writeText( std::string const& text, bool indent = true ) {
                  m_writer->writeText( text, indent );
                  return *this;
              }
  
              template<typename T>
              ScopedElement& writeAttribute( std::string const& name, T const& attribute ) {
                  m_writer->writeAttribute( name, attribute );
                  return *this;
              }
  
          private:
              mutable XmlWriter* m_writer;
          };
  
          XmlWriter()
          :   m_tagIsOpen( false ),
              m_needsNewline( false ),
              m_os( &Catch::cout() )
          {}
  
          XmlWriter( std::ostream& os )
          :   m_tagIsOpen( false ),
              m_needsNewline( false ),
              m_os( &os )
          {}
  
          ~XmlWriter() {
              while( !m_tags.empty() )
                  endElement();
          }
  
  //#  ifndef CATCH_CPP11_OR_GREATER
  //        XmlWriter& operator = ( XmlWriter const& other ) {
  //            XmlWriter temp( other );
  //            swap( temp );
  //            return *this;
  //        }
  //#  else
  //        XmlWriter( XmlWriter const& )              = default;
  //        XmlWriter( XmlWriter && )                  = default;
  //        XmlWriter& operator = ( XmlWriter const& ) = default;
  //        XmlWriter& operator = ( XmlWriter && )     = default;
  //#  endif
  //
  //        void swap( XmlWriter& other ) {
  //            std::swap( m_tagIsOpen, other.m_tagIsOpen );
  //            std::swap( m_needsNewline, other.m_needsNewline );
  //            std::swap( m_tags, other.m_tags );
  //            std::swap( m_indent, other.m_indent );
  //            std::swap( m_os, other.m_os );
  //        }
  
          XmlWriter& startElement( std::string const& name ) {
              ensureTagClosed();
              newlineIfNecessary();
              stream() << m_indent << "<" << name;
              m_tags.push_back( name );
              m_indent += "  ";
              m_tagIsOpen = true;
              return *this;
          }
  
          ScopedElement scopedElement( std::string const& name ) {
              ScopedElement scoped( this );
              startElement( name );
              return scoped;
          }
  
          XmlWriter& endElement() {
              newlineIfNecessary();
              m_indent = m_indent.substr( 0, m_indent.size()-2 );
              if( m_tagIsOpen ) {
                  stream() << "/>\n";
                  m_tagIsOpen = false;
              }
              else {
                  stream() << m_indent << "</" << m_tags.back() << ">\n";
              }
              m_tags.pop_back();
              return *this;
          }
  
          XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
              if( !name.empty() && !attribute.empty() ) {
                  stream() << " " << name << "=\"";
                  writeEncodedText( attribute );
                  stream() << "\"";
              }
              return *this;
          }
  
          XmlWriter& writeAttribute( std::string const& name, bool attribute ) {
              stream() << " " << name << "=\"" << ( attribute ? "true" : "false" ) << "\"";
              return *this;
          }
  
          template<typename T>
          XmlWriter& writeAttribute( std::string const& name, T const& attribute ) {
              if( !name.empty() )
                  stream() << " " << name << "=\"" << attribute << "\"";
              return *this;
          }
  
          XmlWriter& writeText( std::string const& text, bool indent = true ) {
              if( !text.empty() ){
                  bool tagWasOpen = m_tagIsOpen;
                  ensureTagClosed();
                  if( tagWasOpen && indent )
                      stream() << m_indent;
                  writeEncodedText( text );
                  m_needsNewline = true;
              }
              return *this;
          }
  
          XmlWriter& writeComment( std::string const& text ) {
              ensureTagClosed();
              stream() << m_indent << "<!--" << text << "-->";
              m_needsNewline = true;
              return *this;
          }
  
          XmlWriter& writeBlankLine() {
              ensureTagClosed();
              stream() << "\n";
              return *this;
          }
  
          void setStream( std::ostream& os ) {
              m_os = &os;
          }
  
      private:
          XmlWriter( XmlWriter const& );
          void operator=( XmlWriter const& );
  
          std::ostream& stream() {
              return *m_os;
          }
  
          void ensureTagClosed() {
              if( m_tagIsOpen ) {
                  stream() << ">\n";
                  m_tagIsOpen = false;
              }
          }
  
          void newlineIfNecessary() {
              if( m_needsNewline ) {
                  stream() << "\n";
                  m_needsNewline = false;
              }
          }
  
          void writeEncodedText( std::string const& text ) {
              static const char* charsToEncode = "<&\"";
              std::string mtext = text;
              std::string::size_type pos = mtext.find_first_of( charsToEncode );
              while( pos != std::string::npos ) {
                  stream() << mtext.substr( 0, pos );
  
                  switch( mtext[pos] ) {
                      case '<':
                          stream() << "&lt;";
                          break;
                      case '&':
                          stream() << "&amp;";
                          break;
                      case '\"':
                          stream() << "&quot;";
                          break;
                  }
                  mtext = mtext.substr( pos+1 );
                  pos = mtext.find_first_of( charsToEncode );
              }
              stream() << mtext;
          }
  
          bool m_tagIsOpen;
          bool m_needsNewline;
          std::vector<std::string> m_tags;
          std::string m_indent;
          std::ostream* m_os;
      };
  
  }
  #endif // TWOBLUECUBES_CATCH_XMLWRITER_HPP_INCLUDED
  