diff options
Diffstat (limited to 'cpp/src/IceXML/StreamI.cpp')
| -rw-r--r-- | cpp/src/IceXML/StreamI.cpp | 1362 |
1 files changed, 1362 insertions, 0 deletions
diff --git a/cpp/src/IceXML/StreamI.cpp b/cpp/src/IceXML/StreamI.cpp new file mode 100644 index 00000000000..82f30514ca7 --- /dev/null +++ b/cpp/src/IceXML/StreamI.cpp @@ -0,0 +1,1362 @@ +// ********************************************************************** +// +// Copyright (c) 2001 +// MutableRealms, Inc. +// Huntsville, AL, USA +// +// All Rights Reserved +// +// ********************************************************************** + +#include <Ice/Object.h> +#include <Ice/Communicator.h> +#include <Ice/Logger.h> +#include <Ice/LocalException.h> +#include <Ice/ObjectFactory.h> + +#include <IceXML/StreamI.h> + +// +// For input streaming +// +#include <framework/MemBufInputSource.hpp> +#include <util/PlatformUtils.hpp> +#include <util/XMLString.hpp> +#include <util/XMLUniDefs.hpp> +#include <framework/XMLFormatter.hpp> +#include <util/TranscodingException.hpp> + +#include <dom/DOM_DOMException.hpp> +#include <parsers/DOMParser.hpp> + +#include <dom/DOM_Node.hpp> +#include <dom/DOM_NamedNodeMap.hpp> + +#include <sax/ErrorHandler.hpp> +#include <sax/SAXParseException.hpp> +#include <dom/DOMString.hpp> + +using namespace std; +using namespace IceXML; + +// +// Utilities to make the usage of xerces easier. +// +static string +toString(const DOMString& s) +{ + char* t = s.transcode(); + string r(t); + delete[] t; + return r; +} + +static string +toString(const XMLCh* s) +{ + char* t = XMLString::transcode(s); + string r(t); + delete[] t; + return r; +} + +// +// Error handling class for xerces. +// +class DOMTreeErrorReporter : public ErrorHandler +{ +public: + + DOMTreeErrorReporter(const ::Ice::LoggerPtr logger) : + _logger(logger), + _sawErrors(false) + { + } + + virtual void + warning(const SAXParseException& ex) + { + ostringstream os; + os << "xerces: file: \"" << toString(ex.getSystemId()) + << "\", line:" << ex.getLineNumber() + << ", column: " << ex.getColumnNumber() + << "\n,essage: " << toString(ex.getMessage()) << endl; + _logger->warning(os.str()); + } + + virtual void + error(const SAXParseException& ex) + { + _sawErrors = true; + ostringstream os; + os << "xerces: file: \"" << toString(ex.getSystemId()) + << "\", line: " << ex.getLineNumber() + << ", column: " << ex.getColumnNumber() + << "\nmessage: " << toString(ex.getMessage()) << endl; + _logger->error(os.str()); + } + + virtual void + fatalError(const SAXParseException& ex) + { + _sawErrors = true; + ostringstream os; + os << "xerces: file: \"" << toString(ex.getSystemId()) + << "\", line: " << ex.getLineNumber() + << ", column: " << ex.getColumnNumber() + << "\nmessage: " << toString(ex.getMessage()) << endl; + _logger->error(os.str()); + } + + virtual void + resetErrors() + { + } + + bool + getSawErrors() const + { + return _sawErrors; + } + +private: + + ::Ice::LoggerPtr _logger; + bool _sawErrors; +}; + +namespace IceXML +{ + +// +// This is used to reduce the external dependencies on the xerces +// headers. +// +struct StreamInputImpl +{ + StreamInputImpl() : + source(0), + parser(0), + errReporter(0) + { + } + ~StreamInputImpl() + { + delete parser; + delete errReporter; + delete source; + } + + InputSource* source; + DOMParser* parser; + DOMTreeErrorReporter* errReporter; + DOM_Node current; + + list<DOM_Node> nodeStack; + + map<string, ::Ice::ObjectPtr> readObjects; +}; + +} // End namespace IceXML + +// +// A constant string which is used as the name of collection elements. +// +const string IceXML::StreamI::seqElementName("e"); + +IceXML::StreamI::StreamI(const ::Ice::CommunicatorPtr& communicator, std::ostream& os) : + _communicator(communicator), + _input(0), + _os(os), + _nextId(0) +{ + ::Ice::LoggerPtr logger = communicator->getLogger(); + // + // Initialize the XML4C2 system. TODO: This really needs to be + // dealt with as global system state. + // + try + { + XMLPlatformUtils::Initialize(); + } + catch (const XMLException& ex) + { + string err = "xerces: initialize failed: "; + err += toString(ex.getMessage()); + logger->error(err); + throw ::Ice::SystemException(__FILE__, __LINE__); + } +} + + +IceXML::StreamI::StreamI(const ::Ice::CommunicatorPtr& communicator, std::istream& is) : + _communicator(communicator), + _nextId(0) +{ + ::Ice::LoggerPtr logger = communicator->getLogger(); + + // + // Initialize the XML4C2 system. TODO: This really needs to be + // dealt with as global system state. + // + try + { + XMLPlatformUtils::Initialize(); + } + catch (const XMLException& ex) + { + string err = "xerces: initialize failed: "; + err += toString(ex.getMessage()); + logger->error(err); + throw ::Ice::SystemException(__FILE__, __LINE__); + } + + // + // Read the contents of the stream into memory. + // + while (!is.eof()) + { + char buf[1000]; + is.read(buf, sizeof(buf)); + _content.append(buf, is.gcount()); + } + + _input = new StreamInputImpl(); + _input->source = new MemBufInputSource((const XMLByte*)_content.data(), _content.size(), "inputsource"); + + // + // Create our parser, then attach an error handler to the parser. + // The parser will call back to methods of the ErrorHandler if it + // discovers errors during the course of parsing the XML + // document. + // + _input->parser = new DOMParser; + _input->parser->setValidationScheme(DOMParser::Val_Auto); + _input->parser->setDoNamespaces(true); + _input->parser->setDoSchema(true); + //_input->parser->setValidationSchemaFullChecking(true); + + _input->errReporter = new DOMTreeErrorReporter(logger); + _input->parser->setErrorHandler(_input->errReporter); + _input->parser->setCreateEntityReferenceNodes(false); + _input->parser->setToCreateXMLDeclTypeNode(true); + + // TODO: + // parser->setEntityResolver + + // + // Parse the XML file, catching any XML exceptions that might propogate + // out of it. + // + bool errorsOccured = false; + try + { + _input->parser->parse(*_input->source); + int errorCount = _input->parser->getErrorCount(); + if (errorCount > 0) + { + errorsOccured = true; + } + } + catch (const XMLException& ex) + { + ostringstream os; + os << "xerces: parsing error: " << toString(ex.getMessage()); + logger->error(os.str()); + errorsOccured = true; + } + catch (const DOM_DOMException& ex) + { + ostringstream os; + os << "xerces: DOM parsing error: " << toString(ex.msg); + logger->error(os.str()); + errorsOccured = true; + } + + if (errorsOccured) + { + delete _input; + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + // + // The first child of the document is the root node - ignore + // that. Move to the top-level node in the document content. + // + _input->current = _input->parser->getDocument().getFirstChild(); + _input->current = _input->current.getFirstChild(); +} + +IceXML::StreamI::~StreamI() +{ + delete _input; + + // + // And call the termination method (TODO: is this correct - + // reference count?) + // + XMLPlatformUtils::Terminate(); +} + +void +IceXML::StreamI::startWriteDictionary(const string& name, ::Ice::Int size) +{ + ostringstream os; + os << name << " length=\"" << size << "\""; + startWrite(os.str()); +} + +void +IceXML::StreamI::endWriteDictionary() +{ + endWrite(); +} + +void +IceXML::StreamI::startWriteDictionaryElement() +{ + startWrite(seqElementName); +} + +void +IceXML::StreamI::endWriteDictionaryElement() +{ + endWrite(); +} + +void +IceXML::StreamI::startReadDictionary(const string& name, ::Ice::Int& size) +{ + startRead(name); + size = readLength(); + _input->current = _input->current.getFirstChild(); +} + +void +IceXML::StreamI::endReadDictionary() +{ + endRead(); +} + +void +IceXML::StreamI::startReadDictionaryElement() +{ + startRead(seqElementName); +} + +void +IceXML::StreamI::endReadDictionaryElement() +{ + endRead(); +} + +void +IceXML::StreamI::startWriteSequence(const string& name, ::Ice::Int size) +{ + ostringstream os; + os << name << " length=\"" << size << "\""; + startWrite(os.str()); +} + +void +IceXML::StreamI::endWriteSequence() +{ + endWrite(); +} + +void +IceXML::StreamI::startWriteSequenceElement() +{ + startWrite(seqElementName); +} + +void +IceXML::StreamI::endWriteSequenceElement() +{ + endWrite(); +} + +void +IceXML::StreamI::startReadSequence(const string& name, ::Ice::Int& size) +{ + startRead(name); + size = readLength(); + _input->current = _input->current.getFirstChild(); +} + +void +IceXML::StreamI::endReadSequence() +{ + endRead(); +} + +void +IceXML::StreamI::startReadSequenceElement() +{ + startRead(seqElementName); +} + +void +IceXML::StreamI::endReadSequenceElement() +{ + endRead(); +} + +void +IceXML::StreamI::startWriteStruct(const string& name) +{ + startWrite(name); +} + +void +IceXML::StreamI::endWriteStruct() +{ + endWrite(); +} + +void +IceXML::StreamI::startReadStruct(const string& name) +{ + startRead(name); + _input->current = _input->current.getFirstChild(); +} + +void +IceXML::StreamI::endReadStruct() +{ + endRead(); +} + +void +IceXML::StreamI::startWriteException(const string& name) +{ + startWrite(name); +} + +void +IceXML::StreamI::endWriteException() +{ + endWrite(); +} + +void +IceXML::StreamI::startReadException(const string& name) +{ + startRead(name); + _input->current = _input->current.getFirstChild(); +} + +void +IceXML::StreamI::endReadException() +{ + endRead(); +} + +void +IceXML::StreamI::writeEnum(const string& name, const ::Ice::StringSeq& table, ::Ice::Int ordinal) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << table[ordinal] << "</" << name << ">"; +} + +void +IceXML::StreamI::readEnum(const string& name, const ::Ice::StringSeq& table, ::Ice::Int& ordinal) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string value = toString(child.getNodeValue()); + ::Ice::StringSeq::const_iterator p = find(table.begin(), table.end(), value); + if (p == table.end()) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + ordinal = p - table.begin(); + + endRead(); +} + +void +IceXML::StreamI::writeByte(const string& name, ::Ice::Byte value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + + // The schema encoding for xs:byte is a value from -127 to 128. + _os << nl << "<" << name << ">" << (int)value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeByteSeq(const string& name, const ::Ice::ByteSeq& seq) +{ + startWrite(name); + for (::Ice::ByteSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << (int)*p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readByte(const string& name, ::Ice::Byte& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + ::Ice::Int i = atoi(s.c_str()); + if (i < -127 || i > 128) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + value = (::Ice::Byte)i; + + endRead(); +} + +// +// None of the read*Seq methods are very efficient. It's possible to +// write them as follows in a much more efficient manner - but it's +// not as maintainable. +// +// startRead(name); +// ::Ice::Int size = readLength(); +// value.resize(size); +// value_type::iterator p = value.begin(); +// DOM_NodeList children = _input->current.getChildNodes(); +// +// int nchildren = children.getLength(); +// for (int i = 0; i < nchildren; ++i) +// { +// DOM_Node child = children.item(i); +// while (child.getNodeType() != DOM_Node::ELEMENT_NODE) +// { +// child = child.getNextSibling(); +// } +// string name = toString(child.getNodeName()); +// if (name != seqElementName) +// { +// throw ::Ice::UnmarshalException(__FILE__, __LINE__); +// } +// +// child = child.getFirstChild(); +// if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) +// { +// throw ::Ice::UnmarshalException(__FILE__, __LINE__); +// } +// +// string s = toString(child.getNodeValue()); +// *p++ = ???; +// } +// +// endRead(); +// +// +// + +void +IceXML::StreamI::readByteSeq(const string& name, ::Ice::ByteSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readByte(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeBool(const string& name, bool value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << (value ? "true" : "false") << "</" << name << ">"; +} + +void +IceXML::StreamI::writeBoolSeq(const string& name, const ::Ice::BoolSeq& seq) +{ + startWrite(name); + for (::Ice::BoolSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << ((*p) ? "true" : "false") << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readBool(const string& name, bool& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = (s == "true") ? true : false; + + endRead(); +} + +void +IceXML::StreamI::readBoolSeq(const string& name, ::Ice::BoolSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + bool v; + readBool(seqElementName, v); + value[i] = v; + } + } + + endRead(); +} + +void +IceXML::StreamI::writeShort(const string& name, ::Ice::Short value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeShortSeq(const string& name, const ::Ice::ShortSeq& seq) +{ + startWrite(name); + for (::Ice::ShortSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readShort(const string& name, ::Ice::Short& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = atoi(s.c_str()); + + endRead(); +} + +void +IceXML::StreamI::readShortSeq(const string& name, ::Ice::ShortSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readShort(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeInt(const string& name, ::Ice::Int value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeIntSeq(const string& name, const ::Ice::IntSeq& seq) +{ + startWrite(name); + for (::Ice::IntSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readInt(const string& name, ::Ice::Int& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = atoi(s.c_str()); + + endRead(); +} + +void +IceXML::StreamI::readIntSeq(const string& name, ::Ice::IntSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readInt(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeLong(const string& name, ::Ice::Long value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeLongSeq(const string& name, const ::Ice::LongSeq& seq) +{ + startWrite(name); + for (::Ice::LongSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readLong(const string& name, ::Ice::Long& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = atol(s.c_str()); + + endRead(); +} + +void +IceXML::StreamI::readLongSeq(const string& name, ::Ice::LongSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readLong(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeFloat(const string& name, ::Ice::Float value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeFloatSeq(const string& name, const ::Ice::FloatSeq& seq) +{ + startWrite(name); + for (::Ice::FloatSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readFloat(const string& name, ::Ice::Float& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = atof(s.c_str()); + + endRead(); +} + +void +IceXML::StreamI::readFloatSeq(const string& name, ::Ice::FloatSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readFloat(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeDouble(const string& name, ::Ice::Double value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeDoubleSeq(const string& name, const ::Ice::DoubleSeq& seq) +{ + startWrite(name); + for (::Ice::DoubleSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readDouble(const string& name, ::Ice::Double& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (child.isNull() || child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string s = toString(child.getNodeValue()); + value = atof(s.c_str()); + + endRead(); +} + +void +IceXML::StreamI::readDoubleSeq(const string& name, ::Ice::DoubleSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readDouble(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeString(const string& name, const string& value) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + _os << nl << "<" << name << ">" << value << "</" << name << ">"; +} + +void +IceXML::StreamI::writeStringSeq(const string& name, const ::Ice::StringSeq& seq) +{ + startWrite(name); + for (::Ice::StringSeq::const_iterator p = seq.begin(); p != seq.end(); ++p) + { + _os << nl << "<e>" << *p << "</e>"; + } + endWrite(); +} + +void +IceXML::StreamI::readString(const string& name, string& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + if (!child.isNull()) + { + if (child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + value = toString(child.getNodeValue()); + } + else + { + static const string empty(""); + value = empty; + } + + endRead(); +} + +void +IceXML::StreamI::readStringSeq(const string& name, ::Ice::StringSeq& value) +{ + startRead(name); + + ::Ice::Int size = readLength(); + value.resize(size); + if (size > 0) + { + _input->current = _input->current.getFirstChild(); + for (int i = 0; i < size; ++i) + { + readString(seqElementName, value[i]); + } + } + + endRead(); +} + +void +IceXML::StreamI::writeProxy(const string& name, const ::Ice::ObjectPrx& proxy) +{ + // No attributes + assert(name.find_first_of(" \t") == string::npos); + string s = _communicator->proxyToString(proxy); + _os << nl << "<" << name << ">" << s << "</" << name << ">"; +} + +void +IceXML::StreamI::readProxy(const string& name, ::Ice::ObjectPrx& value) +{ + startRead(name); + + DOM_Node child = _input->current.getFirstChild(); + string s; + if (!child.isNull()) + { + if (child.getNodeType() != DOM_Node::TEXT_NODE) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + s = toString(child.getNodeValue()); + } + + value = _communicator->stringToProxy(s); + + endRead(); +} + +void +IceXML::StreamI::writeObject(const string& name, const ::Ice::ObjectPtr& obj) +{ + // + // If at the top level of the document then the object itself must + // be written, otherwise write a reference. + // + bool writeReference = (_elementStack.size() != 0); + + // + // If the object doesn't exist in the map add it. + // + map<Ice::ObjectPtr, ObjectInfo>::iterator p = _objects.find(obj); + if (p == _objects.end()) + { + ostringstream os; + os << "object" << _nextId++; + p = _objects.insert(map<Ice::ObjectPtr, ObjectInfo>::value_type( + obj, ObjectInfo(os.str(), !writeReference))).first; + } + + if (writeReference) + { + _os << nl << "<" << name << " href=\"#" << p->second.id << "\"/>"; + } + else + { + // + // Precondition: If the actual object is being written the + // written flag should be true. + // + assert(p->second.written); + writeObjectData(name, p->second.id, obj); + } +} + +void +IceXML::StreamI::readObject(const string& name, const string& signatureType, const ::Ice::ObjectFactoryPtr& factory, + ::Ice::ObjectPtr& value) +{ + startRead(name); + + // + // Node attributes. Either id & type will be set, or href. + // + string id, type, href; + readAttributes(id, type, href); + + // + // If this object is an href then locate the object. If the object + // has been previously read then it will be contained in the + // readObjects list. Otherwise, it should be in the object-set at + // the top-level of the document. + // + if (!href.empty()) + { + href = href.substr(1); // Skip the '#' + + map<string, ::Ice::ObjectPtr>::const_iterator p = _input->readObjects.find(href); + if (p != _input->readObjects.end()) + { + value = p->second; + endRead(); + return; + } + + // + // The first child of the document is the root node - ignore + // that. Move to the top-level node in the document content. + // + _input->current = _input->parser->getDocument().getFirstChild(); + _input->current = _input->current.getFirstChild(); + while (!_input->current.isNull()) + { + if (_input->current.getNodeType() == DOM_Node::ELEMENT_NODE) + { + string dummy; + readAttributes(id, type, dummy); + if (id == href) + { + break; + } + } + _input->current = _input->current.getNextSibling(); + } + // + // If the object isn't found, that's an error. + // + if (_input->current.isNull()) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + } + + // + // Empty type indicates nil object. + // + if (type.empty()) + { + value = 0; + } + else + { + static const string iceObject("::Ice::Object"); + + if (type == iceObject) + { + value = new ::Ice::Object; + } + else + { + // + // First, determine if there is an installed factory for this + // type. If so use that. If that factory doesn't exist, or it + // doesn't create an object of that type then use the supplied + // factory provided that the types are the same. If no value + // can be created then throw a NoObjectFactoryException. + // + ::Ice::ObjectFactoryPtr userFactory = _communicator->findObjectFactory(type); + if (userFactory) + { + value = userFactory->create(type); + } + + if (!value && type == signatureType) + { + assert(factory); + value = factory->create(type); + assert(value); + } + + if (!value) + { + throw ::Ice::NoObjectFactoryException(__FILE__, __LINE__); + } + } + + // + // Add the object to the readObjects map, move to the first + // child node & unmarshal the object. + // + _input->readObjects.insert(map<string, ::Ice::ObjectPtr>::value_type(id, value)); + _input->current = _input->current.getFirstChild(); + value->__unmarshal(this); + } + + endRead(); +} + +void +IceXML::StreamI::startWrite(const string& element) +{ + _os << nl << '<' << element << '>'; + _os.inc(); + + string::size_type pos = element.find_first_of(" \t"); + if (pos == string::npos) + { + _elementStack.push(element); + } + else + { + _elementStack.push(element.substr(0, pos)); + } +} + +void +IceXML::StreamI::endWrite() +{ + string element = _elementStack.top(); + _elementStack.pop(); + + _os.dec(); + _os << nl << "</" << element << '>'; + + if (_elementStack.size() == 0) + { + dumpUnwrittenObjects(); + } +} + + +void +IceXML::StreamI::startRead(const ::std::string& element) +{ + while (!_input->current.isNull() && _input->current.getNodeType() != DOM_Node::ELEMENT_NODE) + { + _input->current = _input->current.getNextSibling(); + } + if (_input->current.isNull()) + { + cout << "element: " << element << endl; + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + string nodeName = toString(_input->current.getNodeName()); + if (element != nodeName) + { + throw ::Ice::UnmarshalException(__FILE__, __LINE__); + } + + _input->nodeStack.push_back(_input->current); +} + +void +IceXML::StreamI::endRead() +{ + _input->current = _input->nodeStack.back(); + _input->nodeStack.pop_back(); + _input->current = _input->current.getNextSibling(); +} + +void +IceXML::StreamI::dumpUnwrittenObjects() +{ + // + // Precondition: Must be at the top-level. + // + assert(_elementStack.size() == 0); + + // + // It's necessary to run through the set of unwritten objects + // repeatedly until all referenced objects have been written + // (since referenced objects can themselves reference other + // objects). + // + unsigned int nwritten; + do + { + nwritten = 0; + map<Ice::ObjectPtr, ObjectInfo>::iterator p; + for (p = _objects.begin(); p != _objects.end(); ++p) + { + if (!p->second.written) + { + p->second.written = true; + writeObjectData("ice:object", p->second.id, p->first); + ++nwritten; + } + else + { + ++nwritten; + } + } + } + while (_objects.size() != nwritten); +} + +void +IceXML::StreamI::writeObjectData(const string& name, const string& id, const Ice::ObjectPtr& obj) +{ + string xsdType; + string typeId; + + if (obj) + { + // + // Convert the type-id to the equivalent schema type + // definition name. + // + typeId = obj->__getClassIds()[0]; + + static const string xsdPrefix = "_internal."; + static const string xsdSuffix = "Type"; + xsdType.reserve(typeId.size() + xsdPrefix.size() + xsdSuffix.size()); + xsdType += xsdPrefix; + unsigned int i = 0; + if (typeId[0] == ':') // Skip the preceeding "::". + { + i = 2; + } + for (; i < typeId.size(); ++i) + { + if (typeId[i] == ':') + { + xsdType += '.'; + ++i; + } + else + { + xsdType += typeId[i]; + } + } + xsdType += xsdSuffix; + } + else + { + xsdType = ""; + } + + ostringstream os; + os << name << " id=\"" << id << "\" type=\"" << typeId << "\"" + << " xsi:type=\"" << xsdType << "\""; + if (!obj) + { + os << " xsi:nil=\"true\""; + } + + startWrite(os.str()); + if (obj) + { + obj->__marshal(this); + } + endWrite(); +} + +void +IceXML::StreamI::readAttributes(::std::string& id, ::std::string& type, ::std::string& href) +{ + static const string idStr("id"); + static const string typeStr("type"); + static const string hrefStr("href"); + + DOM_NamedNodeMap attributes = _input->current.getAttributes(); + int attrCount = attributes.getLength(); + for (int i = 0; i < attrCount; i++) + { + DOM_Node attribute = attributes.item(i); + string name = toString(attribute.getNodeName()); + if (name == idStr) + { + id = toString(attribute.getNodeValue()); + } + else if (name == typeStr) + { + type = toString(attribute.getNodeValue()); + } + else if (name == hrefStr) + { + href = toString(attribute.getNodeValue()); + } + } +} + +::Ice::Int +IceXML::StreamI::readLength() +{ + static const string lengthStr("length"); + + DOM_NamedNodeMap attributes = _input->current.getAttributes(); + int attrCount = attributes.getLength(); + for (int i = 0; i < attrCount; i++) + { + DOM_Node attribute = attributes.item(i); + string name = toString(attribute.getNodeName()); + if (name == lengthStr) + { + return atoi(toString(attribute.getNodeValue()).c_str()); + } + } + + throw ::Ice::UnmarshalException(__FILE__, __LINE__); +} |