---

CTBxmlOStream.cxx

Go to the documentation of this file.

/*----------------------------------------------------------------------------*/
/* C Tool Box: Designed and implemented by:                                   */
/*    Walter F.J. Mueller   Gesellschaft fuer Schwerionenforschung (GSI)      */
/*                          Planckstrasse 1, D-64291 Darmstadt, Germany       */
/*                  Email:  W.F.J.Mueller@gsi.de                              */
/*                  WWW:    http://www-kp3.gsi.de/www/kp3/people/mueller.html */
/*----------------------------------------------------------------------------*/

#include <string.h>
#include <fstream.h>

#include "CTB.hxx"
#include "CTB_Trace.hxx"
#include "CTBosFill.hxx"
#include "CTBprintf.hxx"
#include "CTBxmlOStream.hxx"

//------------------------------------------+-----------------------------------

CTBxmlOStream::CTBxmlOStream()
  : mp_os(0),
    mb_attached(false),
    mb_autonewline(true),
    mb_autoindent(true),
    mb_bad(false),
    mb_fail(false),
    mi_lasttag(starttag)
{
  CTB_Trace("CTBxmlOStream()");
}

//------------------------------------------+-----------------------------------

CTBxmlOStream::CTBxmlOStream(ostream* p_os)
  : mp_os(p_os),
    mb_attached(p_os),
    mb_autonewline(true),
    mb_autoindent(true),
    mb_bad(false),
    mb_fail(false),
    mi_lasttag(starttag)
{
  CTB_Trace("CTBxmlOStream(ostream*)");
}

//------------------------------------------+-----------------------------------

CTBxmlOStream::CTBxmlOStream(const char* c_filename, int i_mode, int i_prot)
  : mp_os(0),
    mb_attached(false),
    mb_autonewline(true),
    mb_autoindent(true),
    mb_bad(false),
    mb_fail(false),
    mi_lasttag(starttag)
{
  CTB_Trace("CTBxmlOStream(const char*, int, int)");
  Open(c_filename,i_mode,i_prot);
}

//------------------------------------------+-----------------------------------

CTBxmlOStream::~CTBxmlOStream()
{
  CTB_Trace("~CTBxmlOStream()");
  Close();
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::Attach(ostream* p_os)
{
  CTB_Trace("CTBxmlOStream::Attach(ostream*)");
  Close();
  mp_os       = p_os;
  mb_attached = p_os;
  mi_lasttag  = starttag;

  if(mp_os) (*mp_os) << "<?xml version='1.0' standalone='yes'?>";

  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::Open(const char* c_filename, int i_mode, int i_prot)
{
  CTB_Trace("CTBxmlOStream::Open(const char*, int, int)");
  if (c_filename[0] == '-' && c_filename[1] == 0) { // "-" --> use cout
    Attach(&cout);

  } else {
    Close();
    mp_os = new ofstream(c_filename,i_mode,i_prot);
    if (mp_os->bad()) {
      delete mp_os;
      mp_os   = 0;
      mb_fail = true;
      mb_bad  = true;
    }
    if(mp_os) (*mp_os) << "<?xml version='1.0' standalone='yes'?>";
  }
  
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::Close()
{
  CTB_Trace("CTBxmlOStream::Close()");
  if (mp_os) {                              // is noop if no stream open
    if (m_tagstack) {
      while (m_tagstack) PutEndTag();
    }
    *mp_os << endl;
    
    if (!mb_attached) delete mp_os;         // ??? how to handle error on close
    mp_os       = 0;                        // drop reference
    mb_attached = false;
    mb_fail     = false;
    mb_bad      = false;
    mi_lasttag  = starttag;
  }
  return;
}

//------------------------------------------+-----------------------------------

bool CTBxmlOStream::Good() const
{
  CTB_Trace("CTBxmlOStream::Good()");
  return mb_fail ? false : (mp_os ? mp_os->good() : true);
}

//------------------------------------------+-----------------------------------

bool CTBxmlOStream::Bad() const
{
  CTB_Trace("CTBxmlOStream::Bad()");
  return mb_bad ? true : (mp_os ? mp_os->bad() : false);
}
//------------------------------------------+-----------------------------------

bool CTBxmlOStream::Fail() const
{
  CTB_Trace("CTBxmlOStream::Fail()");
  return mb_fail ? true : (mp_os ? mp_os->fail() : false);
}

//------------------------------------------+-----------------------------------

bool CTBxmlOStream::Eof() const
{
  CTB_Trace("CTBxmlOStream::Eof()");
  return mb_bad ? false : (mp_os ? mp_os->eof() : false);
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutStartTag(const char* c_name)
{
  CTB_Trace("CTBxmlOStream::PutStartTag(const char*)");
  if (mp_os) {
    if (mb_autonewline) {
      *mp_os << "\n";
      if (mb_autoindent) *mp_os << CTBosFill(m_tagstack.Size());
    }
    m_tagstack << CTBstring(c_name);
    *mp_os << "<" << c_name << ">";
    mi_lasttag = starttag;
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutEmptyTag(const char* c_name)
{
  CTB_Trace("CTBxmlOStream::PutEmptyTag(const char*)");
  if (mp_os) {
    if (mb_autonewline) {
      *mp_os << "\n";
      if (mb_autoindent) *mp_os << CTBosFill(m_tagstack.Size());
    }
    *mp_os << "<" << c_name << "/>";
    mi_lasttag = emptytag;
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutEndTag()
{
  CTB_Trace("CTBxmlOStream::PutEndTag()");
  if (mp_os) {
    if (m_tagstack) {                       // any pending tags
      CTBstring tagname;
      m_tagstack >> tagname;
      if (mb_autonewline && mi_lasttag != starttag) {
        *mp_os << "\n";
        if (mb_autoindent) *mp_os << CTBosFill(m_tagstack.Size());
      }
      *mp_os << "</" << tagname << ">";
      mi_lasttag = endtag;
    } else {
      SetFail();
    }
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, int i_value, 
                                   const char* c_format, int i_width)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,int,const char*,int)");
  if (mp_os) {
    PutStartTag(c_name);
    (*mp_os) << CTBprintf(i_value,c_format,i_width);
    PutEndTag();
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, unsigned int i_value, 
                                   const char* c_format, int i_width)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,unsigned int,"
                                          "const char*, int)");
  if (mp_os) {
    PutStartTag(c_name);
    (*mp_os) << CTBprintf(i_value,c_format,i_width);
    PutEndTag();
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, long i_value, 
                                   const char* c_format, int i_width)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,long,const char*,int)");
  if (mp_os) {
    PutStartTag(c_name);
    (*mp_os) << CTBprintf(i_value,c_format,i_width);
    PutEndTag();
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, unsigned long i_value, 
                                   const char* c_format, int i_width)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,unsigned long,"
                                          "const char*, int)");
  if (mp_os) {
    PutStartTag(c_name);
    (*mp_os) << CTBprintf(i_value,c_format,i_width);
    PutEndTag();
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, double d_value, 
                                   const char* c_format, int i_width,
                                   int i_precision)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,double,const char*,"
            "int,int)");
  if (mp_os) {
    PutStartTag(c_name);
    (*mp_os) << CTBprintf(d_value,c_format,i_width,i_precision);
    PutEndTag();
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, const char* c_value,
                                   bool b_dropempty)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*, const char*, bool)");
  if (mp_os) {
    if (!b_dropempty  || (c_value && *c_value)) {
      PutStartTag(c_name);
      PutEscapedString(c_value);
      PutEndTag();
    }
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, const CTBstring& value,
                                   bool b_dropempty)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,const CTBstring&,bool)");
  if (mp_os) {
    if (!b_dropempty || value.Length() > 0) {
      PutStartTag(c_name);
      PutEscapedString(value);
      PutEndTag();
    }
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutTaggedValue(const char* c_name, const CTBtime& value,
                                   bool b_dropempty)
{
  CTB_Trace("CTBxmlOStream::PutTaggedValue(const char*,const CTBtime&,bool)");
  if (mp_os) {
    if (!b_dropempty || value.Valid()) {
      PutStartTag(c_name);
      (*mp_os) << value;
      PutEndTag();
    }
  } else {
    SetBad();
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::Dump(int i_indent, ostream& os, const char* p_text) const
{
  CTBosFill bl(i_indent);
  
  os << bl << "--CTBxmlOStream ";
  if (p_text) os << p_text;
  os << " @ " << this << endl;

  os << bl << "    mp_os:          " << mp_os << endl;
  os << bl << "    mb_attached:    " << mb_attached << endl;
  os << bl << "    mb_autonewline: " << mb_autonewline << endl;
  os << bl << "    mb_autoindent:  " << mb_autoindent << endl;
  os << bl << "    mb_fail:        " << mb_fail << endl;
  os << bl << "    mb_bad:         " << mb_bad << endl;
  m_tagstack.Dump(i_indent+2,os,"m_tagstack");

  return;
}

//------------------------------------------+-----------------------------------

CTBxmlOStream&  CTBxmlOStream::operator<<(const char* c_text)
{
  CTB_Trace("CTBxmlOStream::operator<<(const char*)");
  if (mp_os) PutEscapedString(c_text);
  else       SetBad();
  return *this;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutEscapedString(const char* c_text, CTBint i_length)
{
  CTB_Trace("CTBxmlOStream::PutEscapedString(const char*,CTBint)");
  if (!mp_os)  return;
  if (!c_text) return;

  if (i_length < 0) i_length = strlen(c_text);

  for (CTBint i = 0; i < i_length; i++) {
    char c = c_text[i];
    if (c == '<')      *mp_os << "&lt;";
    else if (c == '>') *mp_os << "&gt;";
    else if (c == '&') *mp_os << "&amp;";
    else *mp_os << c;
  }
  return;
}

//------------------------------------------+-----------------------------------

void CTBxmlOStream::PutEscapedString(const CTBstring& string)
{
  CTB_Trace("CTBxmlOStream::PutEscapedString(const CTBstring&)");
  CTBint i_length = string.Length();

  if (i_length == 0) return;
  PutEscapedString(string.Data(),i_length);
  return;
}

//------------------------------------------+-----------------------------------

---