diff options
Diffstat (limited to 'ACE/ace')
-rw-r--r-- | ACE/ace/XML_Utils/XML.mpc | 21 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Error_Handler.cpp | 67 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Error_Handler.h | 60 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Helper.h | 99 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Helper.tpp | 349 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Schema_Resolver.cpp | 77 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Schema_Resolver.h | 110 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Schema_Resolver.tpp | 52 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Typedefs.cpp | 8 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Typedefs.h | 32 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XML_Utils_Export.h | 58 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XercesString.cpp | 167 | ||||
-rw-r--r-- | ACE/ace/XML_Utils/XercesString.h | 82 |
13 files changed, 1182 insertions, 0 deletions
diff --git a/ACE/ace/XML_Utils/XML.mpc b/ACE/ace/XML_Utils/XML.mpc new file mode 100644 index 00000000000..3bd84708aec --- /dev/null +++ b/ACE/ace/XML_Utils/XML.mpc @@ -0,0 +1,21 @@ +// $Id$ + +project (ACE_XML_Utils) : install, acelib, xerces, ace_output { + sharedname += ACE_XML_Utils + dynamicflags += XML_UTILS_BUILD_DLL + + specific { + install_dir = ace/XML_Utils + } + + Header_Files { + XML_Utils_Export.h + } + + Source_Files { + XML_Error_Handler.cpp + XercesString.cpp + XML_Schema_Resolver.cpp + XML_Typedefs.cpp + } +} diff --git a/ACE/ace/XML_Utils/XML_Error_Handler.cpp b/ACE/ace/XML_Utils/XML_Error_Handler.cpp new file mode 100644 index 00000000000..bc459bb4eae --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Error_Handler.cpp @@ -0,0 +1,67 @@ +// $Id$ + +#include "XML_Error_Handler.h" +#include "ace/Log_Msg.h" +#include "ace/Auto_Ptr.h" +#include <xercesc/util/XMLString.hpp> +#include <xercesc/dom/DOMLocator.hpp> +#include <xercesc/sax/SAXParseException.hpp> +#include "XercesString.h" +#include <iostream> + +using xercesc::SAXParseException; + +namespace XML +{ + XML_Error_Handler::XML_Error_Handler (void) + : errors_ (false) + { + } + + XML_Error_Handler::~XML_Error_Handler() + { + } + + void XML_Error_Handler::warning(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Warning: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + } + + void XML_Error_Handler::error(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Error: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + this->errors_ = true; + } + + void XML_Error_Handler::fatalError(const SAXParseException& toCatch) + { + XStr file (toCatch.getSystemId ()); + XStr msg (toCatch.getMessage ()); + + std::cerr << "Fatal Error: " << file << ':' << toCatch.getLineNumber () + << ':' << toCatch.getColumnNumber () << " - " + << msg << std::endl; + this->errors_ = true; + } + + void XML_Error_Handler::resetErrors() + { + this->errors_ = false; + } + + bool + XML_Error_Handler::getErrors (void) const + { + return this->errors_; + } +} diff --git a/ACE/ace/XML_Utils/XML_Error_Handler.h b/ACE/ace/XML_Utils/XML_Error_Handler.h new file mode 100644 index 00000000000..ccc40fd308e --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Error_Handler.h @@ -0,0 +1,60 @@ +//============================================================== +/** + * @file XML_Error_Handler.h + * + * $Id$ + * + * @brief Error handler for Xerces + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + */ +//================================================================ +#ifndef ACE_XML_ERROR_HANDLER_H +#define ACE_XML_ERROR_HANDLER_H + +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "XML_Utils_Export.h" + +#include <xercesc/sax/ErrorHandler.hpp> + +using xercesc::SAXParseException; + +namespace XML +{ + /** + * @class XML_Error_Hander + * + * @brief Error handler for XERCES + * + */ + class XML_Utils_Export XML_Error_Handler + : public xercesc::ErrorHandler + { + public: + + XML_Error_Handler (void); + + ~XML_Error_Handler (void); + + void warning(const SAXParseException& toCatch); + void error(const SAXParseException& toCatch); + void fatalError(const SAXParseException& toCatch); + void resetErrors(); + bool getErrors (void) const; + private : + // Disallow copying + XML_Error_Handler (const XML_Error_Handler&); + XML_Error_Handler& operator= (const XML_Error_Handler&); + + bool errors_; + }; +} + +#include /**/ "ace/post.h" + +#endif /* ACE_XML_ERROR_HANDLER_H */ diff --git a/ACE/ace/XML_Utils/XML_Helper.h b/ACE/ace/XML_Utils/XML_Helper.h new file mode 100644 index 00000000000..3108cce1f6a --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Helper.h @@ -0,0 +1,99 @@ +// $Id$ +//============================================================ +/** + * @file XML_Helper.h + * + * @brief Some helper functions for XML + * + * @author Bala Natarajan <bala@dre.vanderbilt.edu> + * @author William R. Otte <wotte@dre.vanderbilt.edu> + */ +//============================================================ +#ifndef ACE_XML_HELPER_H +#define ACE_XML_HELPER_H +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "XML_Error_Handler.h" +#include "XML_Schema_Resolver.h" + +#include "xercesc/util/XercesDefs.hpp" +#include "xercesc/parsers/XercesDOMParser.hpp" + +#include <memory> + +namespace XERCES_CPP_NAMESPACE +{ + class DOMDocument; + class DOMWriter; + class DOMImplementation; + class DOMDocumentType; +} + +namespace XML +{ + /** + * @class XML_Helper + * + * @brief Helper class for some routine XML stuff. + */ + template <typename Resolver = XML_Schema_Resolver <>, + typename Error_Handler = XML_Error_Handler> + class XML_Helper + { + public: + // XML_Helper (void); + XML_Helper (Resolver *resolver = 0, Error_Handler *eh = 0); + + ~XML_Helper (void); + + /// Create a DOM tree + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *uri) const; + + XERCES_CPP_NAMESPACE::DOMDocument * + create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns, + XERCES_CPP_NAMESPACE::DOMDocumentType * doctype = 0) const; + + XERCES_CPP_NAMESPACE::DOMDocumentType * + create_doctype (const ACE_TCHAR *qn, + const ACE_TCHAR *pid, + const ACE_TCHAR *sid) const; + + /// Writes out a DOMDocument to an XML file + bool write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file) const; + + bool is_initialized (void) const; + + /// Terminate the parser + void terminate_parser (void); + + Resolver &get_resolver (void); + + Error_Handler &get_error_handler (void); + + protected: + /// Intialize the parser + void init_parser (void); + + private: + bool initialized_; + XERCES_CPP_NAMESPACE::DOMImplementation *impl_; + mutable std::auto_ptr<XERCES_CPP_NAMESPACE::XercesDOMParser> parser_; + + Resolver *resolver_; + bool release_resolver_; + Error_Handler *e_handler_; + bool release_e_handler_; + }; +} + +#include "XML_Helper.tpp" + +#include /**/ "ace/post.h" +#endif/*ACE_XML_HELPER_H*/ diff --git a/ACE/ace/XML_Utils/XML_Helper.tpp b/ACE/ace/XML_Utils/XML_Helper.tpp new file mode 100644 index 00000000000..b1177ddcb56 --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Helper.tpp @@ -0,0 +1,349 @@ +//$Id$ +#include "XML_Helper.h" +#include "ace/Auto_Ptr.h" +#include "ace/Log_Msg.h" +#include "xercesc/util/XMLUniDefs.hpp" +#include "xercesc/dom/DOM.hpp" +#include "XML_Error_Handler.h" +#include "XML_Schema_Resolver.h" +#include "xercesc/framework/LocalFileFormatTarget.hpp" +#include "xercesc/dom/DOM.hpp" +#include "XercesString.h" + +#if XERCES_VERSION_MAJOR == 3 +#include "xercesc/dom/DOMLSSerializer.hpp" +#endif + +namespace XML +{ + using xercesc::XMLException; + using xercesc::XMLString; + using xercesc::DOMImplementation; + using xercesc::DOMImplementationRegistry; +// using xercesc::DOMBuilder; + using xercesc::DOMImplementationLS; + using xercesc::XMLUni; + using xercesc::DOMDocument; + using xercesc::DOMException; + using xercesc::DOMDocumentType; + using xercesc::XercesDOMParser; +/* + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::XML_Helper (void) + : initialized_ (false) + { + this->init_parser (); + } +*/ + // TODO this is stub implementation + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::XML_Helper (Resolver *resolver, Error *eh) + : initialized_ (false), + resolver_ (resolver), + release_resolver_(false), + e_handler_ (eh), + release_e_handler_ (false) + { + this->init_parser (); + } + + template <typename Resolver, typename Error> + XML_Helper<Resolver, Error>::~XML_Helper (void) + { + this->terminate_parser (); + } + + template <typename Resolver, typename Error> + bool + XML_Helper<Resolver, Error>::is_initialized (void) const + { + return this->initialized_ == true; + } + + template <typename Resolver, typename Error> + void + XML_Helper<Resolver, Error>::init_parser (void) + { + if (this->initialized_) + return; + + // CIAO_DEBUG ((LM_TRACE, CLINFO + //"XML_Helper<>::is_initialized - Initializing the Xerces runtime \n")); + // Initialize the Xerces run-time + try + { + if (!resolver_) + { + resolver_ = new Resolver (); + release_resolver_ = true; + } + + if (!e_handler_) + { + e_handler_ = new Error (); + release_e_handler_ = true; + } + + xercesc::XMLPlatformUtils::Initialize(); + } + catch (const XMLException& e) + { + char* message = + XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + + throw; + } + catch (...) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Some other exception," + " returning\n")); + + return; + } + + // Instantiate the DOM parser. + static const XMLCh gLS[] = { xercesc::chLatin_L, + xercesc::chLatin_S, + xercesc::chNull }; + + // Get an implementation of the Load-Store (LS) interface + // and cache it for later use + impl_ = + DOMImplementationRegistry::getDOMImplementation(gLS); + + this->initialized_ = true; + return; + } + + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *root, + const ACE_TCHAR *ns, + DOMDocumentType *doctype) const + { + if (root == 0 || ns == 0) + return 0; + + return this->impl_->createDocument (XStr (ns), + XStr (root), + doctype); + } + + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocumentType * + XML_Helper<Resolver, Error>::create_doctype (const ACE_TCHAR *qn, + const ACE_TCHAR *pid, + const ACE_TCHAR *sid) const + { + return this->impl_->createDocumentType (XStr (qn), + XStr (pid), + XStr (sid)); + } + template <typename Resolver, typename Error> + XERCES_CPP_NAMESPACE::DOMDocument * + XML_Helper<Resolver, Error>::create_dom (const ACE_TCHAR *url) const + { + + if (url == 0) + return 0; + + try + { + if (this->parser_.get () == 0) + this->parser_.reset ((new xercesc::XercesDOMParser ())); + + // Perform Namespace processing. + this->parser_->setDoNamespaces (true); + + // Discard comment nodes in the document + this->parser_->setCreateCommentNodes (false); + + // Disable datatype normalization. The XML 1.0 attribute value + // normalization always occurs though. + // this->parser_->setFeature (XMLUni::fgDOMDatatypeNormalization, true); + + // Do not create EntityReference nodes in the DOM tree. No + // EntityReference nodes will be created, only the nodes + // corresponding to their fully expanded sustitution text will be + // created. + this->parser_->setCreateEntityReferenceNodes (false); + + // Perform Validation + this->parser_->setValidationScheme (xercesc::AbstractDOMParser::Val_Always); + + // Do not include ignorable whitespace in the DOM tree. + this->parser_->setIncludeIgnorableWhitespace (false); + + // Enable the parser's schema support. + this->parser_->setDoSchema (true); + + // Enable full schema constraint checking, including checking which + // may be time-consuming or memory intensive. Currently, particle + // unique attribution constraint checking and particle derivation + // restriction checking are controlled by this option. + this->parser_->setValidationSchemaFullChecking (true); + + // The parser will treat validation error as fatal and will exit. + this->parser_->setValidationConstraintFatal (true); + + this->parser_->setErrorHandler (e_handler_); + + this->parser_->setEntityResolver (resolver_); + + this->parser_->parse (ACE_TEXT_ALWAYS_CHAR (url)); + + if (e_handler_ && e_handler_->getErrors ()) + return 0; + + return this->parser_->getDocument (); + } + catch (const DOMException& e) + { + const unsigned int maxChars = 2047; + XMLCh errText[maxChars + 1]; + + if (DOMImplementation::loadDOMExceptionMsg (e.code, + errText, + maxChars)) + { + char* message = + XMLString::transcode (errText); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + } + return 0; + + } + catch (const XMLException& e) + { + char* message = XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + throw 0; + } + catch (...) + { + ACE_DEBUG ((LM_DEBUG, + "(%P|%t) Caught an unknown exception \n")); + throw; + } + + return 0; + } + + template <typename Resolver, typename Error> + void + XML_Helper<Resolver, Error>::terminate_parser (void) + { + if (!this->initialized_) + return; + + try + { + if (release_resolver_ && resolver_) + { + delete resolver_; + resolver_ = 0; + } + + if (release_e_handler_ && e_handler_) + { + delete e_handler_; + e_handler_ = 0; + } + + this->parser_.reset (0); + this->impl_ = 0; + xercesc::XMLPlatformUtils::Terminate(); + } + catch (const XMLException& e) + { + char* message = + XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + throw; + } + + this->initialized_ = false; + return; + } + + template <typename Resolver, typename Error> + Resolver & + XML_Helper<Resolver, Error>::get_resolver (void) + { + if (!this->resolver_) + throw std::exception (); + + return *this->resolver_; + } + + template <typename Resolver, typename Error> + Error & + XML_Helper<Resolver, Error>::get_error_handler (void) + { + if (!this->e_handler_) + throw std::exception (); + + return *this->e_handler_; + } + + template <typename Resolver, typename Error> + bool + XML_Helper<Resolver, Error>::write_DOM (XERCES_CPP_NAMESPACE::DOMDocument *doc, + const ACE_TCHAR *file) const + { + try + { + bool retn; +#if XERCES_VERSION_MAJOR == 3 + XERCES_CPP_NAMESPACE::DOMLSSerializer *serializer (impl_->createLSSerializer ()); + XERCES_CPP_NAMESPACE::DOMConfiguration *ser_config (serializer->getDomConfig ()); + XERCES_CPP_NAMESPACE::DOMLSOutput *output (impl_->createLSOutput ()); + + if (ser_config->canSetParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true)) + ser_config->setParameter(XMLUni::fgDOMWRTFormatPrettyPrint, true); + + XMLFormatTarget *format_target = new XERCES_CPP_NAMESPACE::LocalFileFormatTarget (ACE_TEXT_ALWAYS_CHAR (file)); + + output->setByteStream (format_target); + + retn = serializer->write (doc, output); + + output->release (); + serializer->release (); + return retn; +#else + std::auto_ptr <XERCES_CPP_NAMESPACE::DOMWriter> writer (impl_->createDOMWriter()); + + if (writer->canSetFeature (XMLUni::fgDOMWRTFormatPrettyPrint, + true)) + writer->setFeature (XMLUni::fgDOMWRTFormatPrettyPrint, true); + + std::auto_ptr <xercesc::XMLFormatTarget> ft (new xercesc::LocalFileFormatTarget(ACE_TEXT_ALWAYS_CHAR (file))); + retn = writer->writeNode(ft.get (), *doc); + + return retn; +#endif + } + catch (const xercesc::XMLException &e) + { + char* message = XMLString::transcode (e.getMessage()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_message (message); + + char* name = XMLString::transcode (e.getType()); + ACE_Auto_Basic_Array_Ptr<char> cleanup_name (name); + + ACE_ERROR ((LM_ERROR, "Caught exception while serializing DOM to file.\n" + "Name: %C\n" + "Message: %C\n" + "SrcFile: %C\n" + "SrcLine: %C\n", + name, + message, + e.getSrcFile (), + e.getSrcLine ())); + return false; + } + } +} diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp b/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp new file mode 100644 index 00000000000..a491e2d442e --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.cpp @@ -0,0 +1,77 @@ +// $Id$ +#include "XML_Schema_Resolver.h" + +#include <xercesc/util/PlatformUtils.hpp> +#include <xercesc/util/XercesDefs.hpp> + +#include "XercesString.h" + +#include "ace/Env_Value_T.h" + +#include <iostream> + +namespace XML +{ + Basic_Resolver::Basic_Resolver (const ACE_TCHAR *path) + : path_ (path) + { + } + + XMLCh * + Basic_Resolver::operator() (const XMLCh *const, + const XMLCh *const systemId) const + { + XStr path (path_); + path.append (systemId); + return path.release (); + } + + Environment_Resolver::Environment_Resolver (void) + { + } + + Environment_Resolver::Environment_Resolver (const ACE_TCHAR *variable, + const ACE_TCHAR *relpath) + { + this->add_path (variable, relpath); + } + + using xercesc::XMLPlatformUtils; + + void + Environment_Resolver::add_path (const ACE_TCHAR *variable, + const ACE_TCHAR *relpath) + { + ACE_Env_Value <const ACE_TCHAR *> path_env (variable, + ACE_TEXT("")); + + XStr xpath (path_env); + XStr xrelpath (relpath); + + xpath.append (xrelpath); + + paths_.push_back (xpath); + } + + XMLCh * + Environment_Resolver::operator() (const XMLCh *const, + const XMLCh *const systemId) const + { + for (std::vector<XStr>::const_iterator i = this->paths_.begin (); + i != this->paths_.end (); + ++i) + { + XStr path (*i); + path.append(systemId); + + FileHandle file (XMLPlatformUtils::openFile (path)); + + if (file != 0) + { + XMLPlatformUtils::closeFile (file); + return path.release (); + } + } + return 0; + } +} diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.h b/ACE/ace/XML_Utils/XML_Schema_Resolver.h new file mode 100644 index 00000000000..b849520d319 --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.h @@ -0,0 +1,110 @@ +/** + * @file XML_Schema_Resolver.h + * @author Will Otte <wotte@dre.vanderbilt.edu> + * + * $Id$ + * + * Resolves schema locations. + */ + +#ifndef ACE_XML_SCHEMA_RESOLVER_H +#define ACE_XML_SCHEMA_RESOLVER_H +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include "XML_Utils_Export.h" +#include "XercesString.h" + +#include <xercesc/sax/EntityResolver.hpp> +#include <vector> +#include <string> + +using namespace xercesc; + +namespace XML +{ + // forward decl. + struct NoOp_Resolver; + + /** + * @class XML_Schema_Resolver + * @brief Resolves schema locations + * + * Template argument Resolver should be a functor with an operation + * const ACE_TCHAR * operator () (...arguments from resolveEntity...) + */ + template <typename Resolver = NoOp_Resolver> + class XML_Schema_Resolver + : public virtual EntityResolver + { + public: + XML_Schema_Resolver (void); + + XML_Schema_Resolver (Resolver &resolver); + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + virtual InputSource * resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId); + + Resolver &get_resolver (void); + + private: + XML_Schema_Resolver (XML_Schema_Resolver<Resolver> &); + + Resolver resolver_; + }; + + /** + * @class NoOp_Resolver + * @brief Resolver that does nothing. + */ + struct NoOp_Resolver + { + const XMLCh* operator() (const XMLCh *const, + const XMLCh *const systemId) const + { return systemId; }; + }; + + /** + * @class Basic_Resolver + * @brief Resolves a schema location from a fixed path. + */ + struct Basic_Resolver + { + Basic_Resolver (const ACE_TCHAR *path); + + XMLCh* operator() (const XMLCh *const publicId, + const XMLCh *const systemId) const; + XStr path_; + }; + + /** + * @class Environment_Resolver + * @brief Resolves a schema location from a path from an environment variable. + */ + struct XML_Utils_Export Environment_Resolver + { + Environment_Resolver (void); + + Environment_Resolver (const ACE_TCHAR *variable, + const ACE_TCHAR *path); + + void add_path (const ACE_TCHAR *variable, + const ACE_TCHAR *path); + + XMLCh* operator() (const XMLCh *const publicId, + const XMLCh *const systemId) const; + + std::vector<XStr> paths_; + }; +} + +#include "XML_Schema_Resolver.tpp" + +#include /**/ "ace/post.h" + +#endif /* ACE_XML_SCHEMA_RESOLVER_H */ diff --git a/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp b/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp new file mode 100644 index 00000000000..dba9261e1af --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Schema_Resolver.tpp @@ -0,0 +1,52 @@ +// $Id$ +#ifndef XML_SCHEMA_RESOLVER_TPP +#define XML_SCHEMA_RESOLVER_TPP + +#include "XML_Schema_Resolver.h" +#include "XercesString.h" + +#include <xercesc/framework/LocalFileInputSource.hpp> +#include <xercesc/framework/Wrapper4InputSource.hpp> + +using xercesc::Wrapper4InputSource; +using xercesc::LocalFileInputSource; + + +namespace XML +{ + template<typename Resolver> + XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (void) + : resolver_ () + { + } + + template<typename Resolver> + XML_Schema_Resolver<Resolver>::XML_Schema_Resolver (Resolver &res) + : resolver_ (res) + { + } + + template<typename Resolver> + Resolver & + XML_Schema_Resolver<Resolver>::get_resolver (void) + { + return resolver_; + } + + /// This function is called by the Xerces infrastructure to + /// actually resolve the location of a schema. + template<typename Resolver> + InputSource * + XML_Schema_Resolver<Resolver>::resolveEntity (const XMLCh *const publicId, + const XMLCh *const systemId) + { + XStr path = resolver_ (publicId, systemId); + if (path.begin () == 0) + return 0; + + // Ownership of these objects is given to other people. + return /*new Wrapper4InputSource*/ (new LocalFileInputSource (path.begin ())); + } +} + +#endif /*XML_SCHEMA_RESOLVER_TPP*/ diff --git a/ACE/ace/XML_Utils/XML_Typedefs.cpp b/ACE/ace/XML_Utils/XML_Typedefs.cpp new file mode 100644 index 00000000000..bac591edc9a --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Typedefs.cpp @@ -0,0 +1,8 @@ +// $Id$ + +#include "XML_Typedefs.h" + +namespace XML +{ + XML_Typedef::HELPER XML_Typedef::XML_HELPER; +} diff --git a/ACE/ace/XML_Utils/XML_Typedefs.h b/ACE/ace/XML_Utils/XML_Typedefs.h new file mode 100644 index 00000000000..35a4b7d0cea --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Typedefs.h @@ -0,0 +1,32 @@ +/** + * @file XML_Typedefs.h + * @author William R. Otte <wotte@dre.vanderbilt.edu> + * $Id$ + * Typedefs from the XML Utilities. + */ +#ifndef XML_TYPEDEFS_H +#define XML_TYPEDEFS_H + +#include "XML_Utils_Export.h" +#include "XML_Helper.h" +#include "XML_Schema_Resolver.h" +#include "XML_Error_Handler.h" + +namespace XML +{ + class XML_Utils_Export XML_Typedef + { + public: + typedef ::XML::Environment_Resolver PATH_RESOLVER; + typedef ::XML::XML_Schema_Resolver< ::XML::Environment_Resolver > XML_RESOLVER; + typedef ::XML::XML_Error_Handler ERROR_HANDLER; + typedef ::XML::XML_Helper< XML_RESOLVER, ERROR_HANDLER > HELPER; + + static ERROR_HANDLER _xml_error_handler; + + public: + static HELPER XML_HELPER; + }; +} + +#endif /* XML_TYPEDEFS_H */ diff --git a/ACE/ace/XML_Utils/XML_Utils_Export.h b/ACE/ace/XML_Utils/XML_Utils_Export.h new file mode 100644 index 00000000000..bd8709e2b22 --- /dev/null +++ b/ACE/ace/XML_Utils/XML_Utils_Export.h @@ -0,0 +1,58 @@ + +// -*- C++ -*- +// $Id$ +// Definition for Win32 Export directives. +// This file is generated automatically by generate_export_file.pl XML_Utils +// ------------------------------ +#ifndef XML_UTILS_EXPORT_H +#define XML_UTILS_EXPORT_H + +#include "ace/config-all.h" + +#if defined (ACE_AS_STATIC_LIBS) && !defined (XML_UTILS_HAS_DLL) +# define XML_UTILS_HAS_DLL 0 +#endif /* ACE_AS_STATIC_LIBS && XML_UTILS_HAS_DLL */ + +#if !defined (XML_UTILS_HAS_DLL) +# define XML_UTILS_HAS_DLL 1 +#endif /* ! XML_UTILS_HAS_DLL */ + +#if defined (XML_UTILS_HAS_DLL) && (XML_UTILS_HAS_DLL == 1) +# if defined (XML_UTILS_BUILD_DLL) +# define XML_Utils_Export ACE_Proper_Export_Flag +# define XML_UTILS_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) +# define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# else /* XML_UTILS_BUILD_DLL */ +# define XML_Utils_Export ACE_Proper_Import_Flag +# define XML_UTILS_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) +# define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +# endif /* XML_UTILS_BUILD_DLL */ +#else /* XML_UTILS_HAS_DLL == 1 */ +# define XML_Utils_Export +# define XML_UTILS_SINGLETON_DECLARATION(T) +# define XML_UTILS_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) +#endif /* XML_UTILS_HAS_DLL == 1 */ + +// Set XML_UTILS_NTRACE = 0 to turn on library specific tracing even if +// tracing is turned off for ACE. +#if !defined (XML_UTILS_NTRACE) +# if (ACE_NTRACE == 1) +# define XML_UTILS_NTRACE 1 +# else /* (ACE_NTRACE == 1) */ +# define XML_UTILS_NTRACE 0 +# endif /* (ACE_NTRACE == 1) */ +#endif /* !XML_UTILS_NTRACE */ + +#if (XML_UTILS_NTRACE == 1) +# define XML_UTILS_TRACE(X) +#else /* (XML_UTILS_NTRACE == 1) */ +# if !defined (ACE_HAS_TRACE) +# define ACE_HAS_TRACE +# endif /* ACE_HAS_TRACE */ +# define XML_UTILS_TRACE(X) ACE_TRACE_IMPL(X) +# include "ace/Trace.h" +#endif /* (XML_UTILS_NTRACE == 1) */ + +#endif /* XML_UTILS_EXPORT_H */ + +// End of auto generated file. diff --git a/ACE/ace/XML_Utils/XercesString.cpp b/ACE/ace/XML_Utils/XercesString.cpp new file mode 100644 index 00000000000..9daf5934ce4 --- /dev/null +++ b/ACE/ace/XML_Utils/XercesString.cpp @@ -0,0 +1,167 @@ +// $Id$ + +#include <ostream> +#include <algorithm> + +#include "XercesString.h" +#include "xercesc/util/PlatformUtils.hpp" + +using xercesc::XMLString; +using xercesc::XMLPlatformUtils; + +namespace XML +{ +// On unicode windows, ACE_TCHAR == XMLCh +#if !defined (_MSC_VER) || !defined (ACE_USES_WCHAR) + XStr::XStr (const ACE_TCHAR* str) + : _wstr(0) + { + _wstr = XMLString::transcode(ACE_TEXT_ALWAYS_CHAR (str)); + } +#endif + + XStr::XStr (XMLCh *wstr) + : _wstr(wstr) + { + + } + + XStr::XStr (const XMLCh* wstr) + : _wstr(0) + { + _wstr = XMLString::replicate(wstr); + } + + XStr::XStr (const XStr &right) + : _wstr(0) + { + _wstr = XMLString::replicate(right._wstr); + } + + XStr& XStr::operator= (const XStr& rhs) + { + if (&rhs == this) + return *this; + XStr temp (rhs); + std::swap (this->_wstr, temp._wstr); + return *this; + } + + XStr::~XStr () + { + this->reset (); + } + + const XMLCh* XStr::begin () const + { + return _wstr; + } + + const XMLCh* XStr::end () const + { + return _wstr + size(); + } + + bool XStr::append(const XMLCh *tail) + { + int iTailLen = XMLString::stringLen(tail); + int iWorkLen = XMLString::stringLen(_wstr); + + XMLSize_t bytes = (iWorkLen + iTailLen + 1) * sizeof (XMLCh); + void *tmp = XMLPlatformUtils::fgMemoryManager->allocate (bytes); + XMLCh *result = reinterpret_cast<XMLCh *> (tmp); + + bool bOK = result != 0; + if (bOK) + { + XMLCh *target = result; + XMLString::moveChars(target, _wstr, iWorkLen); + target += iWorkLen; + XMLString::moveChars(target, tail, iTailLen); + target += iTailLen; + *target++ = 0; + XMLString::release(&_wstr); + _wstr = result; + } + return bOK; + } + + bool XStr::erase(const XMLCh *head, const XMLCh *tail) + { + bool bOK = head <= tail && head >= begin() && tail <= end(); + if (bOK) + { + XMLSize_t bytes = (size() - (tail - head) + 1 ) * sizeof (XMLCh); + void *tmp = XMLPlatformUtils::fgMemoryManager->allocate (bytes); + XMLCh *result = reinterpret_cast<XMLCh *> (tmp); + + XMLCh *target = result; + bOK = target != 0; + if (bOK) + { + const XMLCh *cursor = begin(); + + while (cursor != head) *target++ = *cursor++; + cursor = tail; + while ( cursor != end() ) *target++ = *cursor++; + *target ++ = 0; + XMLString::release(&_wstr); + _wstr = result; + } + } + return bOK; + } + + int XStr::size () const + { + return XMLString::stringLen(_wstr); + } + + XMLCh XStr::operator [] (const int i) + { + return _wstr[i]; + } + + XMLCh XStr::operator [] (const int i) const + { + return _wstr[i]; + } + + XMLCh * XStr::release (void) + { + XMLCh* tmp = _wstr; + this->_wstr = 0; + return tmp; + } + + void + XStr::reset (void) + { + if (_wstr) + XMLString::release(&_wstr); + _wstr = 0; + } + + bool operator== (const XStr& lhs, const XStr& rhs) + { + return XMLString::compareIString (lhs,rhs) == 0; + } + + bool operator!= (const XStr& lhs, const XStr& rhs) + { + return !operator==(lhs, rhs); + } + + + std::ostream& + operator<< (std::ostream& o, XStr const& str) + { + char* s = XMLString::transcode (str); + + o << s; + + XMLString::release (&s); // idiots? + return o; + } + +} diff --git a/ACE/ace/XML_Utils/XercesString.h b/ACE/ace/XML_Utils/XercesString.h new file mode 100644 index 00000000000..81c55f74957 --- /dev/null +++ b/ACE/ace/XML_Utils/XercesString.h @@ -0,0 +1,82 @@ +// $Id$ + +#ifndef _XERCESSTRING_H +#define _XERCESSTRING_H + +#include /**/ "ace/pre.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +#pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#include <iosfwd> + +#ifdef __BORLANDC__ +using std::memcpy; +#endif + +#include <xercesc/util/XMLString.hpp> + +// Utility class that provides a std::string like facade to XMLString. +// Doesn't implement all of the methods of std::string. +#include "XML_Utils_Export.h" + +namespace XML +{ + class XML_Utils_Export XStr + { + public: + XStr() : _wstr(0L) { }; + +// On unicode windows, ACE_TCHAR == XMLCh +#if !defined (_MSC_VER) || !defined (ACE_USES_WCHAR) + XStr (const ACE_TCHAR* str); +#endif + + XStr (XMLCh* wstr); + + XStr (const XMLCh* wstr); + + XStr (const XStr& copy); + + XStr& operator= (const XStr& rhs); + + ~XStr(); + + const XMLCh* begin() const; + + const XMLCh* end() const; + + bool append(const XMLCh* tail); + + bool erase (const XMLCh* head, const XMLCh* tail); + + int size() const; + + XMLCh operator [] (const int i); + + XMLCh operator [] (const int i) const; + + operator const XMLCh* () const { return _wstr; }; + + XMLCh * release (void); + + /// Release the held string and free its memory. + void reset (void); + private: + + XMLCh* _wstr; // Internal representation + + }; + + XML_Utils_Export bool operator== (const XStr& lhs, const XStr& rhs); + XML_Utils_Export bool operator!= (const XStr& lhs, const XStr& rhs); + + XML_Utils_Export std::ostream& + operator<< (std::ostream& o, XStr const& str); + +} + +#include /**/ "ace/post.h" + +#endif /* _XERCESSTRING_H */ |