XMLStream.h

Go to the documentation of this file.

/***************************************************************************
 * Copyright (C) 2005 by Benjamin Hadorn (bhadorn@swissinfo.org)           *
 ***************************************************************************
 * Projekt : Zeus
 * Module  : XMLStrean
 * Package : System
 * Author  : Benjamin Hadorn
 * Datum   : $Date: 7.04.08 19:08 $
 * Ablage  : $File$
 * System  : Cell Computing Model
 ***************************************************************************
 * Licence:                                                                *
 *   This library is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU Lesser General Public License as        *
 *   published by the Free Software Foundation; either version             *
 *   2.1 of the License, or (at your option) any later version.            *
 *                                                                         *
 *   This library 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 Lesser General Public License for more details.                   *
 *                                                                         *
 *   You should have received a copy of the GNU Lesser General Public      *
 *   License along with this library; if not, write to the Free Software   *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA  *
 ***************************************************************************/
/***************************************************************************
 Changes :
 $Log: /Development_F/StuderWIN/dev/Zeus/src/zeusbase/System/XMLStream.h $
** 
** 3     7.04.08 19:08 Bha
** Usage of GUID for Interfaces
** 
** 2     4.02.08 11:50 Bha
** using prefix for namespaces implemented
** 
** 1     7.01.08 7:59 Bha
** Created
***************************************************************************/
//---------------------------------------------------------------------------

#ifndef XMLStreamH
#define XMLStreamH
//---------------------------------------------------------------------------

#include <zeusbase/System/XMLDataSource.h>
#include <zeusbase/System/ZObject.h>

BEGIN_NAMESPACE_Zeus

class IXMLParser;


/***************************************************************************/
/***************************************************************************/
zeusbase_class TXMLStream : public TZObject
{
  public:
    TXMLStream(const IString& rData);

    void closeXML();

    //load methods
    Retval loadXML(NAMESPACE_Zeus::IXMLDocument*& rpDocument);
    Retval loadXObjects(IXObject*& rpObject,  bool dDoUnfreeze = true, bool bKeepXObjectAfterClosing = false);

    TString getDocumentStream() const;

    //query methods
    Retval selectNode(const IString& rXPath, IXMLNode*& rpNode);
    Retval selectNode(const wchar_t* pXPath, IXMLNode*& rpNode);
    Retval selectNodes(const IString& rXPath, IXPathResults*& rpResults);
    Retval selectNodes(const wchar_t* pXPath, IXPathResults*& rpResults);
    Retval selectNodeValue(const IString& rXPath, IString& rValue);
    Retval selectNodeValue(const wchar_t* pXPath, IString& rValue);
    Retval selectObject(const IString& rXObjectPath, IXObject*& rpObject);
    Retval selectObject(const wchar_t* pXObjectPath, IXObject*& rpObject);
    Retval selectObjects(const IString& rXObjectPath, IXObjectCollection*& rpCollection);
    Retval selectObjects(const wchar_t* pXObjectPath, IXObjectCollection*& rpCollection);
    Retval selectCastedObject(const IString& rXObjectPath, const InterfaceID& rInterfaceID, IZUnknown*& rpObject);
    Retval selectCastedObject(const wchar_t* pXObjectPath, const InterfaceID& rInterfaceID, IZUnknown*& rpObject);

    void useNamespace(const IString& rPrefix, const IString& rNamespace);
    void useNamespace(const wchar_t* pPrefix, const wchar_t* pNamespace);

    Retval writeNodeValue(const IString& rXPath, const IString& rValue);
    Retval writeNodeValue(const wchar_t* pXPath, const wchar_t* pValue);

  protected:
    virtual ~TXMLStream();

    virtual Retval loadXML_internal();

  private:
    TString m_strData;
    TXMLDataSource m_XMLDocument;
};

/**************************************************************************/
/**************************************************************************/
inline void TXMLStream::closeXML()
{
  m_XMLDocument.closeXML();
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectNode(const wchar_t* pXPath, IXMLNode*& rpNode)
{
  return selectNode(TString(pXPath), rpNode);
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectNodes(const wchar_t* pXPath, IXPathResults*& rpResults)
{
  return selectNodes(TString(pXPath), rpResults);
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectNodeValue(const wchar_t* pXPath, IString& rValue)
{
  return selectNodeValue(TString(pXPath), rValue);
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectObject(const wchar_t* pXObjectPath, IXObject*& rpObject)
{
  return selectObject(TString(pXObjectPath), rpObject);
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectObjects(const wchar_t* pXObjectPath, IXObjectCollection*& rpCollection)
{
  return selectObjects(TString(pXObjectPath), rpCollection);
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::selectCastedObject(const wchar_t* pXObjectPath, const InterfaceID& rInterfaceID, IZUnknown*& rpObject)
{
  return selectCastedObject(TString(pXObjectPath), rInterfaceID, rpObject);
}

/*****************************************************************************/
/*****************************************************************************/
inline void TXMLStream::useNamespace(const IString& rPrefix, const IString& rNamespace)
{
  m_XMLDocument.useNamespace(rPrefix, rNamespace);
}

/*****************************************************************************/
/*****************************************************************************/
inline void TXMLStream::useNamespace(const wchar_t* pPrefix, const wchar_t* pNamespace)
{
  m_XMLDocument.useNamespace(TString(pPrefix), TString(pNamespace));
}

/*****************************************************************************/
/*****************************************************************************/
inline Retval TXMLStream::writeNodeValue(const wchar_t* pXPath, const wchar_t* pValue)
{
  return writeNodeValue(TString(pXPath), TString(pValue));
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::loadXML(NAMESPACE_Zeus::IXMLDocument*& rpDocument)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.loadXML(rpDocument);
  }
  return retValue;
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::loadXObjects(IXObject*& rpObject,  bool dDoUnfreeze /*= true*/, bool bKeepXObjectAfterClosing /*= false*/)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.loadXObjects(rpObject, dDoUnfreeze, bKeepXObjectAfterClosing);
  }
  return retValue;
}

/**************************************************************************/
/**************************************************************************/
inline TString TXMLStream::getDocumentStream() const
{
  TString strRetval;
  if (m_XMLDocument.isAvailable())
  {
    strRetval = m_XMLDocument.getDocumentStream();
  }
  else
  {
    strRetval = m_strData;
  }
  return strRetval;
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectNode(const IString& rXPath, IXMLNode*& rpNode)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectNode(rXPath, rpNode);
  }
  return retValue;
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectNodes(const IString& rXPath, IXPathResults*& rpResults)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectNodes(rXPath, rpResults);
  }
  return retValue;
}


/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectNodeValue(const IString& rXPath, IString& rValue)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectNodeValue(rXPath, rValue);
  }
  return retValue;
}


/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectObject(const IString& rXObjectPath, IXObject*& rpObject)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectObject(rXObjectPath, rpObject);
  }
  return retValue;
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectObjects(const IString& rXObjectPath, IXObjectCollection*& rpCollection)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectObjects(rXObjectPath, rpCollection);
  }
  return retValue;
}

/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::selectCastedObject(const IString& rXObjectPath, const InterfaceID& rInterfaceID, IZUnknown*& rpObject)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.selectCastedObject(rXObjectPath, rInterfaceID, rpObject);
  }
  return retValue;
}


/**************************************************************************/
/**************************************************************************/
inline Retval TXMLStream::writeNodeValue(const IString& rXPath, const IString& rValue)
{
  Retval retValue = loadXML_internal();

  if (retValue == RET_NOERROR)
  {
    retValue = m_XMLDocument.writeNodeValue(rXPath, rValue);
  }
  return retValue;
}


END_NAMESPACE_Zeus

#endif

---

Written by Benjamin Hadorn http://www.xatlantis.ch.
Last change made on Wed Oct 28 21:42:31 2009