spyXmlDocument.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 2006 MaK Technologies, Inc.
 ** All rights reserved.
 *********************************************************************/
/*******************************************************************************
 ** $RCSfile: spyXmlDocument.h,v $ $Revision: 1.10 $ $State: Exp $
 *******************************************************************************/
#ifndef DtSpyXmlDocument_H_
#define DtSpyXmlDocument_H_

#include <rtiMsConfig.h>
#include "spyXmlBlock.h"
#include <mtl/env.h>
#include <mtl/envXMLWriter.h>
#include <vlutil/vlString.h>
#include <vlutil/vlFilename.h>
#include <iosfwd>

class DtSpyXmlDocument;

typedef DtBoost::shared_ptr<DtSpyXmlDocument> DtSpyXmlDocumentSP;
typedef DtBoost::weak_ptr<DtSpyXmlDocument>   DtSpyXmlDocumentWP;


class DT_DLL_WWW DtSpyXmlDocument
{
public:

   // Creates a simple XML document with a root container node with type root type
   // to which other nodes may be added (container is NOT a SpyXmlBlock)
   //
   // HACK!  need the disambiguateCtors parameter to ensure that implicit conversions do not choose
   // this ctor instead of the other versions.
   DtSpyXmlDocument( double disambiguateCtors,
      const MAKRti::DtString& rootType, bool useDtd,
      const MAKRti::DtFilename& dtdFilename = "" );



   // Create a new XML document from an existing XML string
   // HACK!  need the disambiguateCtors parameter to ensure that implicit conversions do not choose
   // this ctor instead of the templateFile version.
   DtSpyXmlDocument( const MAKRti::DtString& xmlString,
      const MAKRti::DtString& rootType,
      const MAKRti::DtString& rootName, double disambiguateCtors );
   
   // Create a new XML document from an existing block
   DtSpyXmlDocument( DtSpyXmlBlockSP root, bool useDtd, const MAKRti::DtFilename& dtdFilename = "" );

   // Create an XML document rooted at the specified node and build the block tree
   // The specified node must have a valid DtSpyXmlBlock representation
   // If rootName is not specified, then assume an unnamed block
   DtSpyXmlDocument( const MAKRti::DtFilename& templateFile, const MAKRti::DtString& rootType,
      const MAKRti::DtString& rootName = "", bool allowUnknownRootBlockType = false );

   virtual ~DtSpyXmlDocument();

   // Set/Get the document root
   // Note: setting the root on an existing document will wipe out the current 
   //       doc tree unless the caller has maintained a pointer to the old tree.
   inline DtSpyXmlBlockSP root() const;
   void setRoot( DtSpyXmlBlockSP root );

   // Output
   virtual const MAKRti::DtString& toString() const;
   virtual void writeXmlToFile( const MAKRti::DtFilename& xmlFile ) const;
   virtual std::ostream& print( std::ostream& ostr, bool formatedXML = true ) const;

protected:

   // Do not allow copy/assignment since modification to copies would modify original
   DtSpyXmlDocument( const DtSpyXmlDocument& );
   DtSpyXmlDocument& operator=( const DtSpyXmlDocument& );
   
   // Build document starting from existing file
   // Non-virtual since this may be called from the constructor
   bool parseFile( const MAKRti::DtFilename& filename );   

   // Build document starting from existing XML string
   // Non-virtual since this may be called from the constructor
   bool parseString( const MAKRti::DtString& xmlString);


protected:
   
   // Document is contained within the root block
   // NOTE: (modifications should be made to the DtSpyXmlBlockSP not directly through
   // the environment direct XML changes are temporary and not reflected in the C++ objects)
   DtSpyXmlBlockSP myRoot;

   // Dtd is optional and used only by root nodes
   bool            myUsingDtdValidation;
   MAKRti::DtFilename      myDtdFilename;

   // myEnvironment is mutable since it may change state as its tree is walked
   // and changes to myEnvironment are temporary unlike changes to the DtSpyXmlBlock
   mutable MAKRti::DtEnvironment myEnvironment;

   // myXml is mutable since it is used only as a cache
   mutable  MAKRti::DtString myXml;

   // Document writer - used to convert the document to XML in memory or file
   // myXmlWriter is persistant so that the XML memory buffer does not re-allocate as often
   std::auto_ptr< DtEnvXMLWriter > myXmlWriter;
};

inline std::ostream& operator<<( std::ostream& ostr, const DtSpyXmlDocument& doc )
{
   return doc.print( ostr, true );
}

DtSpyXmlBlockSP DtSpyXmlDocument::root() const
{
   return myRoot;
}

#endif // DtSpyXmlDocument_H_