freXMLStreamObject.cxx

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freXMLStreamObject.cxx,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#include "freXMLStreamObject.h"
#include "freExceptions.h"
#include "freConvert.h"

#include "fstream"

#include <itksys/SystemTools.hxx>

namespace FREE
{

const std::string XMLStreamObject::cXML_Text ="";


void
XMLStreamObject::
CB_Static_StartElement(void* parser, const char *name,
                       const char **pAttributes)
{
  // Begin element handler that is registered with the XML_Parser.
  // This just casts the user data to an itkXMLParser and calls
  // StartElement.
  static_cast<XMLStreamObject*>(parser)->CB_StartElement(name, pAttributes);
}

void
XMLStreamObject::
CB_Static_EndElement(void* parser, const char *name)
{
  // End element handler that is registered with the XML_Parser.  This
  // just casts the user data to an itkXMLParser and calls EndElement.
  static_cast<XMLStreamObject*>(parser)->CB_EndElement(name);
}

void
XMLStreamObject::
CB_Static_CharacterDataHandler(void* parser, const char* data,
                               int length)
{
  // Character data handler that is registered with the XML_Parser.
  // This just casts the user data to an itkXMLParser and calls
  // CharacterDataHandler.
  static_cast<XMLStreamObject*>(parser)->CB_CharacterDataHandler(data, length);
}

void
XMLStreamObject::
LoadFromString(const std::string& rsRawData)
{
  m_Parser = XML_ParserCreate(0);
  XML_SetElementHandler(m_Parser,&CB_Static_StartElement,&CB_Static_EndElement);
  XML_SetCharacterDataHandler(m_Parser, NULL);
  XML_SetUserData(m_Parser,this);

  Reset();
  ResetRequirements();
  ResetLoadingHelpers();

  m_psLoadData = &rsRawData;

  bool result = XML_Parse(m_Parser,m_psLoadData->c_str(),m_psLoadData->size(),true);
    
  if(!result)
  {
    std::string errorMsg(XML_ErrorString(XML_GetErrorCode(m_Parser)));
    std::string errorPos = Convert::ToStr(XML_GetCurrentLineNumber(m_Parser))+":"+Convert::ToStr(XML_GetCurrentColumnNumber(m_Parser));
    throwExceptionMacro("Expat error while parsing raw string. Error: "<<errorMsg<<"; Error position: "<<errorPos);
  }

  XML_ParserFree(m_Parser);
  
  FinalizeLoading();

  CheckValidLoading();
  
  ResetLoadingHelpers();
};

std::string XMLStreamObject::SaveToString() const
{
  return SaveToString(0);
};

void
XMLStreamObject::
SaveToFile(const std::string& sFileName,
           const std::string& sXSLT,
           const std::string& sEncoding) const
{
  std::ofstream file;

  std::ios_base::openmode iOpenFlag = std::ios_base::out | std::ios_base::trunc;
        file.open(sFileName.c_str(), iOpenFlag );

        if (!file.is_open()) throwExceptionMacro("Cannot open or create specified file to save. Filename: "<<sFileName);

  try
  {
    if (!sEncoding.empty())     file <<"<?xml version=\"1.0\" encoding=\""<<sEncoding<<"\"?>\n";
    if (!sXSLT.empty()) file <<"<?xml-stylesheet type=\"text/xsl\" href=\""<<sXSLT<<"\"?>\n";
    file << this->SaveToString();
    file.close();
  }
  catchAllNPassMacro("Unknown error occured while saving setup. Please check error log for further information.");
};

void
XMLStreamObject::
LoadFromFile(const std::string& sFileName)
{
  std::ifstream file;

  std::ios_base::openmode iOpenFlag = std::ios_base::in;// | std::ios_base::binary;
        file.open(sFileName.c_str(), iOpenFlag );

        if (!file.is_open()) throwExceptionMacro("Cannot open or create specified file to load. Filename: " << sFileName);

  try
  {
    std::streamsize filesize = itksys::SystemTools::FileLength(sFileName.c_str());
    char *buffer = new char [filesize];

    file.read(buffer,filesize);

    std::streamsize gsize = file.gcount();

    std::string data(buffer,gsize);

    delete[] buffer;
    file.close();

    this->LoadFromString(data);
  }
  catchAllNPassMacro("Unknown error occured while loading setup. Please check error log for further information.");
};

void
XMLStreamObject::
Reset()
{
  //Should be reimplimented by derived classes.
};

const std::string
XMLStreamObject::
GetXMLTag() const
{ return m_sXMLTag; };

void
XMLStreamObject::
CB_StartElement(const char * name,const char **pAttributes)
{
  if (m_iActSubElementLevel==0)
  {
    if (name == GetXMLTag())
    {
      AttributesLoadProcessing(ConvertExpatAttrToMap(pAttributes));
      XML_SetCharacterDataHandler(m_Parser, &CB_Static_CharacterDataHandler);
    }
                else throwExceptionMacro("Wrong xml tag for used xml stream object class. Used Tag: " << name << ".Required Tag: " << this->GetXMLTag());
  }
  else if (m_iActSubElementLevel==1)
  {
    CommitSubElement();
    m_lContentStartPos = -1;
    m_lContentStopPos = -1;
    m_lElementStopPos = -1;

    //Now take care about the found element
    m_sActSubElementTag = name;
    m_ActSubElementAttributes = ConvertExpatAttrToMap(pAttributes);
    m_lElementStartPos = XML_GetCurrentByteIndex(m_Parser);

    //Set handle to be aware of the data beginning
    XML_SetCharacterDataHandler(m_Parser, &CB_Static_CharacterDataHandler);
  }
  else XML_SetCharacterDataHandler(m_Parser, NULL); //another start tag of a sub element has appeared, we don't need to wait for text data anymore

  m_iActSubElementLevel++;
};

void
XMLStreamObject::
CB_EndElement(const char *name)
{
  m_iActSubElementLevel--;

  if (m_iActSubElementLevel==1) //reached the end tag of a top level element
  {
    m_lContentStopPos = XML_GetCurrentByteIndex(m_Parser);

    //Set handle to be aware of text data before the next tag
    XML_SetCharacterDataHandler(m_Parser, &CB_Static_CharacterDataHandler);
  }
  else if (m_iActSubElementLevel==0) //reached and of xml element
  {
    CommitSubElement();
  };
};

void
XMLStreamObject::
CB_CharacterDataHandler(const char *inData, int inLength)
{
  CommitSubElement();
  m_lContentStartPos = XML_GetCurrentByteIndex(m_Parser);
  m_lContentStopPos = -1;
  m_lElementStopPos = -1;

  //we only need this callback once, to get aware of the begining pos of sub element data
  XML_SetCharacterDataHandler(m_Parser, NULL);
};

XMLStreamObject&
XMLStreamObject::
operator = (const XMLStreamObject& rXMLStreamObject)
{
  m_sXMLTag = rXMLStreamObject.GetXMLTag();
  // all other private members are helpers of the loading process, so only valid while
  // loading and for this reason not needed to be copied.
  
  return *this;
};

XMLStreamObject::
XMLStreamObject(const std::string& sXMLTag)
{
  m_sXMLTag = sXMLTag;
  ResetLoadingHelpers();
};

XMLStreamObject::
XMLStreamObject(const XMLStreamObject& rXMLStreamObject)
{
  ResetLoadingHelpers();
  *this = rXMLStreamObject;
};

XMLStreamObject::
~XMLStreamObject()
{
  ResetLoadingHelpers();
};

void
XMLStreamObject::
SubElementLoadProcessing(const std::string& rsXMLSubTag, const std::string& rsXMLSubElement, const std::string& rsXMLSubData)
{
  if (rsXMLSubTag!=cXML_Text) throwExceptionMacro("Unknown xml tag, unable to load value. Incorrect Tag: " << rsXMLSubTag);
  //Should be reimplimented by derived classes, to create the loading behaviour for
  //different sub elements of this class.
  //Reminder: plain text data elements have a rsXMLSubTag==cXML_Text.
};

void
XMLStreamObject::
AttributesLoadProcessing(const AttributesType& rAttributes)
{
  //Should be reimplimented by derived classes, to adjust their loading behaviour
  //depending on the attributes of this class.
};

void
XMLStreamObject::
SaveAttributes(AttributesSaveListType& rAttributes) const
{
  //Should be reimplimented by derived classes, to adjust their xml attribute saving behaviour.
};

std::string
XMLStreamObject::
SaveData(const unsigned int& iDepth, bool& bHasSubElements) const
{
        bHasSubElements = false;
  return "";
  //Should be reimplimented by derived classes, to adjust their xml data saving behaviour.
};

std::string
XMLStreamObject::
SaveToString(const unsigned int& iDepth) const
{
  AttributesSaveListType attrs;
  std::string sAttrs = "";

  try
  {
    SaveAttributes(attrs);
  }
  catchAllNPassMacro("Unkown error when saving attributes of tag. Tag: "+this->GetXMLTag());
  
        bool bHasSubElements = true;

  try
  {
    sAttrs = ConvertAttributesToString(attrs);
  }
  catchAllNPassMacro("Unkown error when converting attribute structure into save string. Tag: "+this->GetXMLTag());

  std::string sElement = "";
  try
  {
    sElement = SaveData(iDepth, bHasSubElements);
  }
  catchAllNPassMacro("Unkown error when converting element data into save string. Tag: "+this->GetXMLTag());
  
  std::string sResult = "<";
    
  try
  {
    sResult += GetXMLTag();
  }
  catchAllNPassMacro("Unkown error when adding XML Tag. Tag: "+this->GetXMLTag());
        
  try
  {
    AddIndentation(sResult, iDepth);
  }
  catchAllNPassMacro("Unkown error when adding indentation. Tag: "+this->GetXMLTag());

  std::string sEndTag = "";

  try
  {
    sEndTag = "</"+GetXMLTag()+">";
    if (bHasSubElements)
          {
                  AddIndentation(sEndTag, iDepth);
                  sEndTag = "\n"+sEndTag;
          }
  }
  catchAllNPassMacro("Unkown error when formatting end tag. Tag: "+this->GetXMLTag());

  try
  {
    if (sAttrs.size()) sResult += " "+sAttrs;
  }
  catchAllNPassMacro("Unkown error when adding attr string. Tag: "+this->GetXMLTag());

  try
  {
    if (sElement.size()) sResult += ">"+sElement+sEndTag;
          else sResult += " />";
  }
  catchAllNPassMacro("Unkown error when adding element string. Tag: "+this->GetXMLTag());

  try
  {
    return sResult;
  }
  catchAllNPassMacro("Unkown error when returning result. Tag: "+this->GetXMLTag());

  return "";
};

std::string
XMLStreamObject::
CreateSimpleElement(const std::string& sTag, const std::string& sValue)
{
  std::string sResult = "<"+sTag+">"+sValue+"</"+sTag+">";
        return sResult;
};

void
XMLStreamObject::
AddSubElement(std::string& sData, const std::string& sTag, const std::string& sValue, const unsigned int& iParentalDepth)
{
  try
  {
    std::string sResult = CreateSimpleElement(sTag,sValue);
    AddIndentation(sResult,iParentalDepth+1);
    sData += '\n'+sResult;
  }
  catchAllNPassStaticMacro("Unknown error while adding subelement to save string. Subelement tag: "+sTag+"; value: "+sValue+"; parental depth: "+Convert::ToStr(iParentalDepth));
};

void
XMLStreamObject::
AddSubElement(std::string& sData, const std::string& sTag, const std::string& sValue, const AttributesType& rAttributes, const unsigned int& iParentalDepth)
{
  try
  {
    std::string sAttr = "";
    for (AttributesType::const_iterator pos = rAttributes.begin(); pos != rAttributes.end(); pos++)
    {
      sAttr += " "+pos->first+"=\""+pos->second+"\"";
    }
    std::string sResult = "<"+sTag+sAttr+">"+sValue+"</"+sTag+">";
    AddIndentation(sResult,iParentalDepth+1);
    sData += '\n'+sResult;
  }
  catchAllNPassStaticMacro("Unknown error while adding subelement to save string. Subelement tag: "+sTag+"; value: "+sValue+"; parental depth: "+Convert::ToStr(iParentalDepth));
};

void
XMLStreamObject::
AddSubElement(std::string& sData, const XMLStreamObject* pSubElement, const unsigned int& iParentalDepth)
{
  std::string sTag = "NULL sub element";
  if (pSubElement)
  {
    sTag = pSubElement->GetXMLTag();
    std::string sResult = "";
    try
    {
      sResult = pSubElement->SaveToString(iParentalDepth+1);
    }
    catchAllNPassStaticMacro("Unknown error while generating subelement save string. Subelement tag: "+sTag+"; parental depth: "+Convert::ToStr(iParentalDepth));
    try
    {
      sData += "\n"+sResult;
    }
    catchAllNPassStaticMacro("Unknown error while adding subelement save string. Subelement tag: "+sTag+"; parental depth: "+Convert::ToStr(iParentalDepth)+"; sub element string: "+sResult);
  }
  else
  {
                std::string sLocation;
                GetStaticLocationMacro( sLocation );
    FREE::LogException("Warning", "Passed sub element was NULL.",sLocation);
  }
};

void
XMLStreamObject::
AddSubElement(std::string& sData, const std::string& sSubElement, const unsigned int& iParentalDepth)
{
  try
  {
    std::string sResult = sSubElement;
    AddIndentation(sResult,iParentalDepth+1);
    sData += '\n'+sResult;
  }
  catchAllNPassStaticMacro("Unknown error while adding subelement to save string. parental depth: "+Convert::ToStr(iParentalDepth)+"; subelement save string: "+sSubElement);
};

void
XMLStreamObject::
AddIndentation(std::string& sData, const unsigned int& iDepth)
{
  std::string sIndent;
  for (unsigned int i=0; i<iDepth; i++) sIndent+="   ";
  sData = sIndent+sData;
};

bool
XMLStreamObject::
CheckValidLoading() const
{
  if (m_NeededSubElements.size()>0)
  {
    std::string sMissing;
    STLStringVector::const_iterator pos;

    for (pos = m_NeededSubElements.begin(); pos != m_NeededSubElements.end(); pos++)
    {
      sMissing += *pos + " ";
    };
    throwExceptionMacro("Loading of object was invalid, because required sub tags where missing. Please check xml file with schema definition. Missing tags: " << sMissing);
  }
  return true;
  //Should be reimplimented by derived classes, to adjust the checking.
};

void
XMLStreamObject::
SetNeededSubElements()
{
  //Should be reimplimented by derived classes, to set needed elements for loading validation.
  //Use AddNeededSubElement() to add an element
  //If this function is called by XMLStreamObject, the list of needed elements has been cleared.
};

void
XMLStreamObject::
AddNeededSubElement(const std::string& sSubElementTag)
{
  m_NeededSubElements.push_back(sSubElementTag);
};

void
XMLStreamObject::
NotifyFoundSubElement(const std::string& sSubElementTag)
{
  STLStringVector::iterator pos;

  for (pos = m_NeededSubElements.begin(); pos != m_NeededSubElements.end(); pos++)
  {
    if ((*pos)==sSubElementTag)
    {
      m_NeededSubElements.erase(pos);
      return;
    }
  };
};

void
XMLStreamObject::
ResetRequirements()
{
  m_NeededSubElements.clear();
  SetNeededSubElements();
};

void
XMLStreamObject::
ResetLoadingHelpers()
{
  m_iActSubElementLevel = 0;
  m_sActSubElementTag.erase();
  m_ActSubElementAttributes.clear();
  m_psLoadData = NULL;
  m_lElementStartPos = -1;
  m_lElementStopPos = -1;
  m_lContentStartPos = -1;
  m_lContentStopPos = -1;
};

XMLStreamObject::AttributesType
XMLStreamObject::
ConvertExpatAttrToMap(const char** pAttributes)
{
  AttributesType attrs;
  
  const char** pActAttr = pAttributes;

  while (*pActAttr)
  {
    std::string sKey = *pActAttr;
    pActAttr++;
    std::string sValue = *pActAttr;
    pActAttr++;
    attrs.insert(AttributeType(sKey,sValue));
  };

  return attrs;
};

std::string
XMLStreamObject::
ExtractSubElementXmlString()
{
  if (m_lElementStartPos==-1) return "";
  
  if (m_lElementStartPos>m_lElementStopPos) return "";

  return m_psLoadData->substr(m_lElementStartPos,m_lElementStopPos-m_lElementStartPos);
};

std::string
XMLStreamObject::
ExtractSubElementContentString()
{
  if (m_lContentStartPos==-1) return "";
  
  if (m_lContentStartPos>m_lContentStopPos) return "";

  return m_psLoadData->substr(m_lContentStartPos,m_lContentStopPos-m_lContentStartPos);
};

void
XMLStreamObject::
CommitSubElement()
{
  if (m_lContentStopPos>-1) //there is a sub element finished
  {
    m_lElementStopPos = XML_GetCurrentByteIndex(m_Parser);
    SubElementLoadProcessing(m_sActSubElementTag,ExtractSubElementXmlString(),ExtractSubElementContentString());
    NotifyFoundSubElement(m_sActSubElementTag);
  }
  else if (m_lContentStartPos>-1) //there is xml text information
  {
    m_lContentStopPos = XML_GetCurrentByteIndex(m_Parser);
    SubElementLoadProcessing(cXML_Text,ExtractSubElementContentString(),ExtractSubElementContentString());
  };
};

std::string
XMLStreamObject::
ConvertAttributesToString(const AttributesSaveListType& rAttributes)
{
  std::string sResult;

  AttributesSaveListType::const_iterator pos;

  for (pos = rAttributes.begin(); pos!= rAttributes.end(); pos++)
  {
    std::string sAttribut = pos->first + "=";
    
    if (pos->second.find_first_of('"') == -1) sAttribut += "\""+pos->second+"\"";
    else if (pos->second.find_first_of('\'') == -1) sAttribut += "'"+pos->second+"'";
    else throwStaticExceptionMacro("Attribute value contains \" and '. Invalid value, cannot be saved as xml attribute. Invalid Value: " << pos->second);
  
    sResult += sAttribut+" ";
  }

  if (sResult.size()!=0) sResult.resize(sResult.size()-1);
  //erase the last char (space) because not needed

  return sResult;
};

}//end of namespace FREE

---