int ParserEngine::handleExternalEntityRef(XML_Parser parser, const XML_Char* context, const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId)
{
ParserEngine* pThis = reinterpret_cast<ParserEngine*>(XML_GetUserData(parser));
if (!context && !pThis->_externalParameterEntities) return XML_STATUS_ERROR;
if (context && !pThis->_externalGeneralEntities) return XML_STATUS_ERROR;
InputSource* pInputSource = 0;
EntityResolver* pEntityResolver = 0;
EntityResolverImpl defaultResolver;
XMLString sysId(systemId);
XMLString pubId;
if (publicId) pubId.assign(publicId);
URI uri(fromXMLString(pThis->_context.back()->getSystemId()));
uri.resolve(fromXMLString(sysId));
if (pThis->_pEntityResolver)
{
pEntityResolver = pThis->_pEntityResolver;
pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
}
if (!pInputSource && pThis->_externalGeneralEntities)
{
pEntityResolver = &defaultResolver;
pInputSource = pEntityResolver->resolveEntity(publicId ? &pubId : 0, toXMLString(uri.toString()));
}
if (pInputSource)
{
XML_Parser extParser = XML_ExternalEntityParserCreate(pThis->_parser, context, 0);
if (!extParser) throw XMLException("Cannot create external entity parser");
try
{
pThis->parseExternal(extParser, pInputSource);
}
catch (XMLException&)
{
pEntityResolver->releaseInputSource(pInputSource);
XML_ParserFree(extParser);
throw;
}
pEntityResolver->releaseInputSource(pInputSource);
XML_ParserFree(extParser);
return XML_STATUS_OK;
}
else return XML_STATUS_ERROR;
}
Xml_string toXMLString(const QList<double>& doublelist)
{
QString result = "";
QList<double>::const_iterator dax;
for (dax = doublelist.begin(); dax != doublelist.end(); ++dax)
result += toXMLString(*dax) + " ";
return result;
}
Xml_string toXMLString(const QVector<int>& intlist)
{
QString result = "";
QVector<int>::const_iterator dax;
for (dax = intlist.begin(); dax != intlist.end(); ++dax)
result += toXMLString(*dax) + " ";
return result;
}
Xml_string toXMLString(const QList<float>& floatlist)
{
QString result = "";
QList<float>::const_iterator dax;
for (dax = floatlist.begin(); dax != floatlist.end(); ++dax)
result += toXMLString(*dax) + " ";
return result;
}
TCHAR * CTaskModel::ToXMLString()
{
StringBuffer sb;
if(m_pTaskManager)EnterCriticalSection(m_pTaskManager->GetCriticalSection());
toXMLString(sb, true);
if(m_pTaskManager)LeaveCriticalSection(m_pTaskManager->GetCriticalSection());
return sb.toString();
}
void XMLWriter::writeMarkup(const std::string& str) const
{
#if defined(XML_UNICODE_WCHAR_T)
const XMLString xmlString = toXMLString(str);
writeXML(xmlString);
#else
_pTextConverter->write(str.data(), (int) str.size());
#endif
}
namespace XML {
const XMLString MutationEvent::DOMSubtreeModified = toXMLString("DOMSubtreeModified");
const XMLString MutationEvent::DOMNodeInserted = toXMLString("DOMNodeInserted");
const XMLString MutationEvent::DOMNodeRemoved = toXMLString("DOMNodeRemoved");
const XMLString MutationEvent::DOMNodeRemovedFromDocument = toXMLString("DOMNodeRemovedFromDocument");
const XMLString MutationEvent::DOMNodeInsertedIntoDocument = toXMLString("DOMNodeInsertedIntoDocument");
const XMLString MutationEvent::DOMAttrModified = toXMLString("DOMAttrModified");
const XMLString MutationEvent::DOMCharacterDataModified = toXMLString("DOMCharacterDataModified");
MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type):
Event(pOwnerDocument, type, 0, true, false),
_change(MODIFICATION),
_pRelatedNode(0)
{
}
MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode):
Event(pOwnerDocument, type, pTarget, canBubble, cancelable),
_change(MODIFICATION),
_pRelatedNode(relatedNode)
{
}
MutationEvent::MutationEvent(Document* pOwnerDocument, const XMLString& type, EventTarget* pTarget, bool canBubble, bool cancelable, Node* relatedNode,
const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change):
Event(pOwnerDocument, type, pTarget, canBubble, cancelable),
_prevValue(prevValue),
_newValue(newValue),
_attrName(attrName),
_change(change),
_pRelatedNode(relatedNode)
{
}
MutationEvent::~MutationEvent()
{
}
void MutationEvent::initMutationEvent(const XMLString& type, bool canBubble, bool cancelable, Node* relatedNode,
const XMLString& prevValue, const XMLString& newValue, const XMLString& attrName, AttrChangeType change)
{
initEvent(type, canBubble, cancelable);
_pRelatedNode = relatedNode;
_prevValue = prevValue;
_newValue = newValue;
_attrName = attrName;
_change = change;
}
} } // namespace Poco::XML
namespace XML {
const XMLString DOMImplementation::FEATURE_XML = toXMLString("xml");
const XMLString DOMImplementation::FEATURE_CORE = toXMLString("core");
const XMLString DOMImplementation::FEATURE_EVENTS = toXMLString("events");
const XMLString DOMImplementation::FEATURE_MUTATIONEVENTS = toXMLString("mutationevents");
const XMLString DOMImplementation::FEATURE_TRAVERSAL = toXMLString("traversal");
const XMLString DOMImplementation::VERSION_1_0 = toXMLString("1.0");
const XMLString DOMImplementation::VERSION_2_0 = toXMLString("2.0");
DOMImplementation::DOMImplementation()
{
}
DOMImplementation::~DOMImplementation()
{
}
bool DOMImplementation::hasFeature(const XMLString& feature, const XMLString& version) const
{
XMLString lcFeature = Poco::toLower(feature);
return (lcFeature == FEATURE_XML && version == VERSION_1_0) ||
(lcFeature == FEATURE_CORE && version == VERSION_2_0) ||
(lcFeature == FEATURE_EVENTS && version == VERSION_2_0) ||
(lcFeature == FEATURE_MUTATIONEVENTS && version == VERSION_2_0) ||
(lcFeature == FEATURE_TRAVERSAL && version == VERSION_2_0);
}
DocumentType* DOMImplementation::createDocumentType(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const
{
return new DocumentType(0, name, publicId, systemId);
}
Document* DOMImplementation::createDocument(const XMLString& namespaceURI, const XMLString& qualifiedName, DocumentType* doctype) const
{
Document* pDoc = new Document(doctype);
if (namespaceURI.empty())
pDoc->appendChild(pDoc->createElement(qualifiedName))->release();
else
pDoc->appendChild(pDoc->createElementNS(namespaceURI, qualifiedName))->release();
return pDoc;
}
const DOMImplementation& DOMImplementation::instance()
{
static Poco::SingletonHolder<DOMImplementation> sh;
return *sh.get();
}
} } // namespace Poco::XML
namespace XML {
const XMLString CDATASection::NODE_NAME = toXMLString("#cdata-section");
CDATASection::CDATASection(Document* pOwnerDocument, const XMLString& data):
Text(pOwnerDocument, data)
{
}
CDATASection::CDATASection(Document* pOwnerDocument, const CDATASection& sec):
Text(pOwnerDocument, sec)
{
}
CDATASection::~CDATASection()
{
}
Text* CDATASection::splitText(unsigned long offset)
{
Node* pParent = parentNode();
if (!pParent) throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
int n = length() - offset;
Text* pNew = ownerDocument()->createCDATASection(substringData(offset, n));
deleteData(offset, n);
pParent->insertBefore(pNew, nextSibling())->release();
return pNew;
}
const XMLString& CDATASection::nodeName() const
{
return NODE_NAME;
}
unsigned short CDATASection::nodeType() const
{
return Node::CDATA_SECTION_NODE;
}
Node* CDATASection::copyNode(bool deep, Document* pOwnerDocument) const
{
return new CDATASection(pOwnerDocument, *this);
}
} } // namespace Poco::XML
namespace XML {
const XMLString DocumentFragment::NODE_NAME = toXMLString("#document-fragment");
DocumentFragment::DocumentFragment(Document* pOwnerDocument):
AbstractContainerNode(pOwnerDocument)
{
}
DocumentFragment::DocumentFragment( Document* pOwnerDocument, const DocumentFragment& fragment):
AbstractContainerNode(pOwnerDocument, fragment)
{
}
DocumentFragment::~DocumentFragment()
{
}
const XMLString& DocumentFragment::nodeName() const
{
return NODE_NAME;
}
unsigned short DocumentFragment::nodeType() const
{
return Node::DOCUMENT_FRAGMENT_NODE;
}
Node* DocumentFragment::copyNode(bool deep, Document* pOwnerDocument) const
{
DocumentFragment* pClone = new DocumentFragment(pOwnerDocument, *this);
if (deep)
{
Node* pCur = firstChild();
while (pCur)
{
pClone->appendChild(static_cast<AbstractNode*>(pCur)->copyNode(deep, pOwnerDocument))->release();
pCur = pCur->nextSibling();
}
}
return pClone;
}
} } // namespace Poco::XML
namespace XML {
const XMLString Entity::NODE_NAME = toXMLString("#entity");
Entity::Entity(Document* pOwnerDocument, const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName):
AbstractContainerNode(pOwnerDocument),
_name(name),
_publicId(publicId),
_systemId(systemId),
_notationName(notationName)
{
}
Entity::Entity(Document* pOwnerDocument, const Entity& entity):
AbstractContainerNode(pOwnerDocument, entity),
_name(entity._name),
_publicId(entity._publicId),
_systemId(entity._systemId),
_notationName(entity._notationName)
{
}
Entity::~Entity()
{
}
const XMLString& Entity::nodeName() const
{
return _name;
}
unsigned short Entity::nodeType() const
{
return Node::ENTITY_NODE;
}
Node* Entity::copyNode(bool deep, Document* pOwnerDocument) const
{
return new Entity(pOwnerDocument, *this);
}
} } // namespace Poco::XML
namespace XML {
const XMLString XMLReader::FEATURE_VALIDATION = toXMLString("http://xml.org/sax/features/validation");
const XMLString XMLReader::FEATURE_NAMESPACES = toXMLString("http://xml.org/sax/features/namespaces");
const XMLString XMLReader::FEATURE_NAMESPACE_PREFIXES = toXMLString("http://xml.org/sax/features/namespace-prefixes");
const XMLString XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES = toXMLString("http://xml.org/sax/features/external-general-entities");
const XMLString XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES = toXMLString("http://xml.org/sax/features/external-parameter-entities");
const XMLString XMLReader::FEATURE_STRING_INTERNING = toXMLString("http://xml.org/sax/features/string-interning");
const XMLString XMLReader::PROPERTY_DECLARATION_HANDLER = toXMLString("http://xml.org/sax/properties/declaration-handler");
const XMLString XMLReader::PROPERTY_LEXICAL_HANDLER = toXMLString("http://xml.org/sax/properties/lexical-handler");
XMLReader::~XMLReader()
{
}
} } // namespace Poco::XML
void XMLWriter::addNamespaceAttributes(AttributeMap& attributeMap)
{
NamespaceSupport::PrefixSet prefixes;
_namespaces.getDeclaredPrefixes(prefixes);
for (NamespaceSupport::PrefixSet::const_iterator it = prefixes.begin(); it != prefixes.end(); ++it)
{
XMLString prefix = *it;
XMLString uri = _namespaces.getURI(prefix);
XMLString qname = NamespaceSupport::XMLNS_NAMESPACE_PREFIX;
if (!prefix.empty())
{
qname.append(toXMLString(MARKUP_COLON));
qname.append(prefix);
}
attributeMap[qname] = uri;
}
}
namespace XML {
const XMLString Comment::NODE_NAME = toXMLString("#comment");
Comment::Comment(Document* pOwnerDocument, const XMLString& rData):
CharacterData(pOwnerDocument, rData)
{
}
Comment::Comment(Document* pOwnerDocument, const Comment& comment):
CharacterData(pOwnerDocument, comment)
{
}
Comment::~Comment()
{
}
const XMLString& Comment::nodeName() const
{
return NODE_NAME;
}
unsigned short Comment::nodeType() const
{
return Node::COMMENT_NODE;
}
Node* Comment::copyNode(bool deep, Document* pOwnerDocument) const
{
return new Comment(pOwnerDocument, *this);
}
} } // namespace Poco::XML
void XMLWriter::addAttributes(AttributeMap& attributeMap, const Attributes& attributes, const XMLString& elementNamespaceURI)
{
for (int i = 0; i < attributes.getLength(); i++)
{
XMLString namespaceURI = attributes.getURI(i);
XMLString localName = attributes.getLocalName(i);
XMLString qname = attributes.getQName(i);
if (!localName.empty())
{
XMLString prefix;
if (namespaceURI != elementNamespaceURI)
prefix = _namespaces.getPrefix(namespaceURI);
if (!prefix.empty())
{
qname = prefix;
qname.append(toXMLString(MARKUP_COLON));
}
else qname.clear();
qname.append(localName);
}
attributeMap[qname] = attributes.getValue(i);
}
}
namespace XML {
const XMLString SAXParser::FEATURE_PARTIAL_READS = toXMLString("http://www.appinf.com/features/enable-partial-reads");
SAXParser::SAXParser():
_namespaces(true),
_namespacePrefixes(false)
{
}
SAXParser::SAXParser(const XMLString& encoding):
_engine(encoding),
_namespaces(true),
_namespacePrefixes(false)
{
}
SAXParser::~SAXParser()
{
}
void SAXParser::setEncoding(const XMLString& encoding)
{
_engine.setEncoding(encoding);
}
const XMLString& SAXParser::getEncoding() const
{
return _engine.getEncoding();
}
void SAXParser::addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding)
{
_engine.addEncoding(name, pEncoding);
}
void SAXParser::setEntityResolver(EntityResolver* pResolver)
{
_engine.setEntityResolver(pResolver);
}
EntityResolver* SAXParser::getEntityResolver() const
{
return _engine.getEntityResolver();
}
void SAXParser::setDTDHandler(DTDHandler* pDTDHandler)
{
_engine.setDTDHandler(pDTDHandler);
}
DTDHandler* SAXParser::getDTDHandler() const
{
return _engine.getDTDHandler();
}
void SAXParser::setContentHandler(ContentHandler* pContentHandler)
{
_engine.setContentHandler(pContentHandler);
}
ContentHandler* SAXParser::getContentHandler() const
{
return _engine.getContentHandler();
}
void SAXParser::setErrorHandler(ErrorHandler* pErrorHandler)
{
_engine.setErrorHandler(pErrorHandler);
}
ErrorHandler* SAXParser::getErrorHandler() const
{
return _engine.getErrorHandler();
}
void SAXParser::setFeature(const XMLString& featureId, bool state)
{
if (featureId == XMLReader::FEATURE_VALIDATION || featureId == XMLReader::FEATURE_STRING_INTERNING)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_VALIDATION));
else if (featureId == XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES)
_engine.setExternalGeneralEntities(state);
else if (featureId == XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES)
_engine.setExternalParameterEntities(state);
else if (featureId == XMLReader::FEATURE_NAMESPACES)
_namespaces = state;
else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
_namespacePrefixes = state;
else if (featureId == FEATURE_PARTIAL_READS)
_engine.setEnablePartialReads(state);
else throw SAXNotRecognizedException(fromXMLString(featureId));
}
bool SAXParser::getFeature(const XMLString& featureId) const
{
if (featureId == XMLReader::FEATURE_VALIDATION || featureId == XMLReader::FEATURE_STRING_INTERNING)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_VALIDATION));
else if (featureId == XMLReader::FEATURE_EXTERNAL_GENERAL_ENTITIES)
return _engine.getExternalGeneralEntities();
else if (featureId == XMLReader::FEATURE_EXTERNAL_PARAMETER_ENTITIES)
return _engine.getExternalParameterEntities();
else if (featureId == XMLReader::FEATURE_NAMESPACES)
return _namespaces;
else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
return _namespacePrefixes;
else if (featureId == FEATURE_PARTIAL_READS)
return _engine.getEnablePartialReads();
else throw SAXNotRecognizedException(fromXMLString(featureId));
}
void SAXParser::setProperty(const XMLString& propertyId, const XMLString& value)
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER || propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
throw SAXNotSupportedException(std::string("property does not take a string value: ") + fromXMLString(propertyId));
else
throw SAXNotRecognizedException(fromXMLString(propertyId));
}
void SAXParser::setProperty(const XMLString& propertyId, void* value)
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
_engine.setDeclHandler(reinterpret_cast<DeclHandler*>(value));
else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
_engine.setLexicalHandler(reinterpret_cast<LexicalHandler*>(value));
else throw SAXNotRecognizedException(fromXMLString(propertyId));
}
void* SAXParser::getProperty(const XMLString& propertyId) const
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
return _engine.getDeclHandler();
else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
return _engine.getLexicalHandler();
else throw SAXNotSupportedException(fromXMLString(propertyId));
}
void SAXParser::parse(InputSource* pInputSource)
{
if (pInputSource->getByteStream() || pInputSource->getCharacterStream())
{
setupParse();
_engine.parse(pInputSource);
}
else parse(pInputSource->getSystemId());
}
void SAXParser::parse(const XMLString& systemId)
{
setupParse();
EntityResolverImpl entityResolver;
InputSource* pInputSource = entityResolver.resolveEntity(0, systemId);
if (pInputSource)
{
try
{
_engine.parse(pInputSource);
}
catch (...)
{
entityResolver.releaseInputSource(pInputSource);
throw;
}
entityResolver.releaseInputSource(pInputSource);
}
else throw XMLException("Cannot resolve system identifier", fromXMLString(systemId));
}
void SAXParser::parseString(const std::string& xml)
{
parseMemoryNP(xml.data(), xml.size());
}
void SAXParser::parseMemoryNP(const char* xml, std::size_t size)
{
setupParse();
_engine.parse(xml, size);
}
void SAXParser::setupParse()
{
if (_namespaces && !_namespacePrefixes)
_engine.setNamespaceStrategy(new NoNamespacePrefixesStrategy);
else if (_namespaces && _namespacePrefixes)
_engine.setNamespaceStrategy(new NamespacePrefixesStrategy);
else
_engine.setNamespaceStrategy(new NoNamespacesStrategy);
}
} } // namespace Poco::XML
namespace XML {
const XMLString DOMParser::FEATURE_WHITESPACE = toXMLString("http://www.appinf.com/features/no-whitespace-in-element-content");
DOMParser::DOMParser(NamePool* pNamePool):
_pNamePool(pNamePool),
_whitespace(true)
{
if (_pNamePool) _pNamePool->duplicate();
_saxParser.setFeature(XMLReader::FEATURE_NAMESPACES, true);
_saxParser.setFeature(XMLReader::FEATURE_NAMESPACE_PREFIXES, true);
}
DOMParser::~DOMParser()
{
if (_pNamePool) _pNamePool->release();
}
void DOMParser::setEncoding(const XMLString& encoding)
{
_saxParser.setEncoding(encoding);
}
const XMLString& DOMParser::getEncoding() const
{
return _saxParser.getEncoding();
}
void DOMParser::addEncoding(const XMLString& name, Poco::TextEncoding* pEncoding)
{
_saxParser.addEncoding(name, pEncoding);
}
void DOMParser::setFeature(const XMLString& name, bool state)
{
if (name == FEATURE_WHITESPACE)
_whitespace = state;
else
_saxParser.setFeature(name, state);
}
bool DOMParser::getFeature(const XMLString& name) const
{
if (name == FEATURE_WHITESPACE)
return _whitespace;
else
return _saxParser.getFeature(name);
}
Document* DOMParser::parse(const XMLString& uri)
{
if (_whitespace)
{
DOMBuilder builder(_saxParser, _pNamePool);
return builder.parse(uri);
}
else
{
WhitespaceFilter filter(&_saxParser);
DOMBuilder builder(filter, _pNamePool);
return builder.parse(uri);
}
}
Document* DOMParser::parse(InputSource* pInputSource)
{
if (_whitespace)
{
DOMBuilder builder(_saxParser, _pNamePool);
return builder.parse(pInputSource);
}
else
{
WhitespaceFilter filter(&_saxParser);
DOMBuilder builder(filter, _pNamePool);
return builder.parse(pInputSource);
}
}
Document* DOMParser::parseString(const std::string& xml)
{
return parseMemory(xml.data(), xml.size());
}
Document* DOMParser::parseMemory(const char* xml, std::size_t size)
{
if (_whitespace)
{
DOMBuilder builder(_saxParser, _pNamePool);
return builder.parseMemoryNP(xml, size);
}
else
{
WhitespaceFilter filter(&_saxParser);
DOMBuilder builder(filter, _pNamePool);
return builder.parseMemoryNP(xml, size);
}
}
EntityResolver* DOMParser::getEntityResolver() const
{
return _saxParser.getEntityResolver();
}
void DOMParser::setEntityResolver(EntityResolver* pEntityResolver)
{
_saxParser.setEntityResolver(pEntityResolver);
}
}
XMLString XMLWriter::newPrefix()
{
std::ostringstream str;
str << "ns" << ++_prefix;
return toXMLString(str.str());
}
namespace XML {
const XMLString NamespaceSupport::EMPTY_STRING;
const XMLString NamespaceSupport::XML_NAMESPACE = toXMLString("http://www.w3.org/XML/1998/namespace");
const XMLString NamespaceSupport::XML_NAMESPACE_PREFIX = toXMLString("xml");
const XMLString NamespaceSupport::XMLNS_NAMESPACE = toXMLString("http://www.w3.org/xmlns/2000/");
const XMLString NamespaceSupport::XMLNS_NAMESPACE_PREFIX = toXMLString("xmlns");
NamespaceSupport::NamespaceSupport()
{
reset();
}
NamespaceSupport::~NamespaceSupport()
{
}
bool NamespaceSupport::declarePrefix(const XMLString& prefix, const XMLString& namespaceURI)
{
poco_assert (_contexts.size() > 0);
Context& ctx = _contexts.back();
if (ctx.find(prefix) == ctx.end())
{
ctx.insert(Context::value_type(prefix, namespaceURI));
return true;
}
else return false;
}
bool NamespaceSupport::undeclarePrefix(const XMLString& prefix)
{
for (ContextVec::reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
Context::iterator it = rit->find(prefix);
if (it != rit->end())
{
rit->erase(it);
return true;
}
}
return false;
}
void NamespaceSupport::getDeclaredPrefixes(PrefixSet& prefixes) const
{
prefixes.clear();
const Context& ctx = _contexts.back();
for (Context::const_iterator it = ctx.begin(); it != ctx.end(); ++it)
prefixes.insert(it->first);
}
const XMLString& NamespaceSupport::getPrefix(const XMLString& namespaceURI) const
{
for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
{
if (it->second == namespaceURI)
return it->first;
}
}
return EMPTY_STRING;
}
bool NamespaceSupport::isMapped(const XMLString& namespaceURI) const
{
for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
{
if (it->second == namespaceURI)
return true;
}
}
return false;
}
void NamespaceSupport::getPrefixes(PrefixSet& prefixes) const
{
prefixes.clear();
for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
{
const XMLString& prefix = it->first;
if (!prefix.empty() && prefixes.find(prefix) == prefixes.end())
prefixes.insert(it->first);
}
}
}
void NamespaceSupport::getPrefixes(const XMLString& namespaceURI, PrefixSet& prefixes) const
{
prefixes.clear();
for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
for (Context::const_iterator it = rit->begin(); it != rit->end(); ++it)
{
const XMLString& prefix = it->first;
if (it->second == namespaceURI && !prefix.empty() && prefixes.find(prefix) == prefixes.end())
prefixes.insert(it->first);
}
}
}
const XMLString& NamespaceSupport::getURI(const XMLString& prefix) const
{
for (ContextVec::const_reverse_iterator rit = _contexts.rbegin(); rit != _contexts.rend(); ++rit)
{
Context::const_iterator it = rit->find(prefix);
if (it != rit->end())
return it->second;
}
return EMPTY_STRING;
}
void NamespaceSupport::pushContext()
{
_contexts.push_back(Context());
}
void NamespaceSupport::popContext()
{
_contexts.pop_back();
}
bool NamespaceSupport::processName(const XMLString& qname, XMLString& namespaceURI, XMLString& localName, bool isAttribute) const
{
XMLString prefix;
Name::split(qname, prefix, localName);
if (prefix.empty() && isAttribute)
{
namespaceURI.clear();
return true;
}
else
{
namespaceURI = getURI(prefix);
return !namespaceURI.empty() || prefix.empty();
}
}
void NamespaceSupport::reset()
{
_contexts.clear();
pushContext();
declarePrefix(XML_NAMESPACE_PREFIX, XML_NAMESPACE);
declarePrefix(XMLNS_NAMESPACE_PREFIX, XMLNS_NAMESPACE);
}
} } // namespace Poco::XML
namespace XML {
const XMLString DOMSerializer::CDATA = toXMLString("CDATA");
DOMSerializer::DOMSerializer():
_pEntityResolver(0),
_pDTDHandler(0),
_pContentHandler(0),
_pErrorHandler(0),
_pDeclHandler(0),
_pLexicalHandler(0)
{
}
DOMSerializer::~DOMSerializer()
{
}
void DOMSerializer::setEntityResolver(EntityResolver* pEntityResolver)
{
_pEntityResolver = pEntityResolver;
}
EntityResolver* DOMSerializer::getEntityResolver() const
{
return _pEntityResolver;
}
void DOMSerializer::setDTDHandler(DTDHandler* pDTDHandler)
{
_pDTDHandler = pDTDHandler;
}
DTDHandler* DOMSerializer::getDTDHandler() const
{
return _pDTDHandler;
}
void DOMSerializer::setContentHandler(ContentHandler* pContentHandler)
{
_pContentHandler = pContentHandler;
}
ContentHandler* DOMSerializer::getContentHandler() const
{
return _pContentHandler;
}
void DOMSerializer::setErrorHandler(ErrorHandler* pErrorHandler)
{
_pErrorHandler = pErrorHandler;
}
ErrorHandler* DOMSerializer::getErrorHandler() const
{
return _pErrorHandler;
}
void DOMSerializer::setFeature(const XMLString& featureId, bool state)
{
if (featureId == XMLReader::FEATURE_NAMESPACES)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACES));
else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACE_PREFIXES));
else
throw SAXNotRecognizedException(fromXMLString(featureId));
}
bool DOMSerializer::getFeature(const XMLString& featureId) const
{
if (featureId == XMLReader::FEATURE_NAMESPACES)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACES));
else if (featureId == XMLReader::FEATURE_NAMESPACE_PREFIXES)
throw SAXNotSupportedException(fromXMLString(XMLReader::FEATURE_NAMESPACE_PREFIXES));
else
throw SAXNotRecognizedException(fromXMLString(featureId));
}
void DOMSerializer::setProperty(const XMLString& propertyId, const XMLString& value)
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER || propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
throw SAXNotSupportedException(std::string("property does not take a string value: ") + fromXMLString(propertyId));
else
throw SAXNotRecognizedException(fromXMLString(propertyId));
}
void DOMSerializer::setProperty(const XMLString& propertyId, void* value)
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
_pDeclHandler = reinterpret_cast<DeclHandler*>(value);
else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
_pLexicalHandler = reinterpret_cast<LexicalHandler*>(value);
else throw SAXNotRecognizedException(fromXMLString(propertyId));
}
void* DOMSerializer::getProperty(const XMLString& propertyId) const
{
if (propertyId == XMLReader::PROPERTY_DECLARATION_HANDLER)
return _pDeclHandler;
else if (propertyId == XMLReader::PROPERTY_LEXICAL_HANDLER)
return _pLexicalHandler;
else throw SAXNotSupportedException(fromXMLString(propertyId));
}
void DOMSerializer::serialize(const Node* pNode)
{
poco_check_ptr (pNode);
handleNode(pNode);
}
void DOMSerializer::parse(InputSource* pSource)
{
throw XMLException("The DOMSerializer cannot parse an InputSource");
}
void DOMSerializer::parse(const XMLString& systemId)
{
throw XMLException("The DOMSerializer cannot parse from a system identifier");
}
void DOMSerializer::parseMemoryNP(const char* xml, std::size_t size)
{
throw XMLException("The DOMSerializer cannot parse from memory");
}
void DOMSerializer::iterate(const Node* pNode) const
{
while (pNode)
{
handleNode(pNode);
pNode = pNode->nextSibling();
}
}
void DOMSerializer::handleNode(const Node* pNode) const
{
switch (pNode->nodeType())
{
case Node::ELEMENT_NODE:
handleElement(static_cast<const Element*>(pNode));
break;
case Node::TEXT_NODE:
handleCharacterData(static_cast<const Text*>(pNode));
break;
case Node::CDATA_SECTION_NODE:
handleCDATASection(static_cast<const CDATASection*>(pNode));
break;
case Node::ENTITY_NODE:
handleEntity(static_cast<const Entity*>(pNode));
break;
case Node::PROCESSING_INSTRUCTION_NODE:
handlePI(static_cast<const ProcessingInstruction*>(pNode));
break;
case Node::COMMENT_NODE:
handleComment(static_cast<const Comment*>(pNode));
break;
case Node::DOCUMENT_NODE:
handleDocument(static_cast<const Document*>(pNode));
break;
case Node::DOCUMENT_TYPE_NODE:
handleDocumentType(static_cast<const DocumentType*>(pNode));
break;
case Node::DOCUMENT_FRAGMENT_NODE:
handleFragment(static_cast<const DocumentFragment*>(pNode));
break;
case Node::NOTATION_NODE:
handleNotation(static_cast<const Notation*>(pNode));
break;
}
}
void DOMSerializer::handleElement(const Element* pElement) const
{
if (_pContentHandler)
{
AutoPtr<NamedNodeMap> pAttrs = pElement->attributes();
AttributesImpl saxAttrs;
for (unsigned long i = 0; i < pAttrs->length(); ++i)
{
Attr* pAttr = static_cast<Attr*>(pAttrs->item(i));
saxAttrs.addAttribute(pAttr->namespaceURI(), pAttr->localName(), pAttr->nodeName(), CDATA, pAttr->value(), pAttr->specified());
}
_pContentHandler->startElement(pElement->namespaceURI(), pElement->localName(), pElement->tagName(), saxAttrs);
}
iterate(pElement->firstChild());
if (_pContentHandler)
_pContentHandler->endElement(pElement->namespaceURI(), pElement->localName(), pElement->tagName());
}
void DOMSerializer::handleCharacterData(const Text* pText) const
{
if (_pContentHandler)
{
const XMLString& data = pText->data();
_pContentHandler->characters(data.c_str(), 0, (int) data.length());
}
}
void DOMSerializer::handleComment(const Comment* pComment) const
{
if (_pLexicalHandler)
{
const XMLString& data = pComment->data();
_pLexicalHandler->comment(data.c_str(), 0, (int) data.length());
}
}
void DOMSerializer::handlePI(const ProcessingInstruction* pPI) const
{
if (_pContentHandler) _pContentHandler->processingInstruction(pPI->target(), pPI->data());
}
void DOMSerializer::handleCDATASection(const CDATASection* pCDATA) const
{
if (_pLexicalHandler) _pLexicalHandler->startCDATA();
handleCharacterData(pCDATA);
if (_pLexicalHandler) _pLexicalHandler->endCDATA();
}
void DOMSerializer::handleDocument(const Document* pDocument) const
{
if (_pContentHandler) _pContentHandler->startDocument();
const DocumentType* pDoctype = pDocument->doctype();
if (pDoctype) handleDocumentType(pDoctype);
iterate(pDocument->firstChild());
if (_pContentHandler) _pContentHandler->endDocument();
}
void DOMSerializer::handleDocumentType(const DocumentType* pDocumentType) const
{
if (_pLexicalHandler) _pLexicalHandler->startDTD(pDocumentType->name(), pDocumentType->publicId(), pDocumentType->systemId());
iterate(pDocumentType->firstChild());
if (_pLexicalHandler) _pLexicalHandler->endDTD();
}
void DOMSerializer::handleFragment(const DocumentFragment* pFragment) const
{
iterate(pFragment->firstChild());
}
void DOMSerializer::handleNotation(const Notation* pNotation) const
{
if (_pDTDHandler) _pDTDHandler->notationDecl(pNotation->nodeName(), &pNotation->publicId(), &pNotation->systemId());
}
void DOMSerializer::handleEntity(const Entity* pEntity) const
{
if (_pDTDHandler) _pDTDHandler->unparsedEntityDecl(pEntity->nodeName(), &pEntity->publicId(), pEntity->systemId(), pEntity->notationName());
}
} } // namespace Poco::XML
namespace XML {
const XMLString AbstractNode::NODE_NAME = toXMLString("#node");
const XMLString AbstractNode::EMPTY_STRING;
AbstractNode::AbstractNode(Document* pOwnerDocument):
_pParent(0),
_pNext(0),
_pOwner(pOwnerDocument),
_pEventDispatcher(0)
{
}
AbstractNode::AbstractNode(Document* pOwnerDocument, const AbstractNode& node):
_pParent(0),
_pNext(0),
_pOwner(pOwnerDocument),
_pEventDispatcher(0)
{
}
AbstractNode::~AbstractNode()
{
delete _pEventDispatcher;
if (_pNext) _pNext->release();
}
void AbstractNode::autoRelease()
{
_pOwner->autoReleasePool().add(this);
}
const XMLString& AbstractNode::nodeName() const
{
return NODE_NAME;
}
const XMLString& AbstractNode::getNodeValue() const
{
return EMPTY_STRING;
}
void AbstractNode::setNodeValue(const XMLString& value)
{
throw DOMException(DOMException::NO_DATA_ALLOWED_ERR);
}
Node* AbstractNode::parentNode() const
{
return _pParent;
}
NodeList* AbstractNode::childNodes() const
{
return new ChildNodesList(this);
}
Node* AbstractNode::firstChild() const
{
return 0;
}
Node* AbstractNode::lastChild() const
{
return 0;
}
Node* AbstractNode::previousSibling() const
{
if (_pParent)
{
AbstractNode* pSibling = _pParent->_pFirstChild;
while (pSibling)
{
if (pSibling->_pNext == this) return pSibling;
pSibling = pSibling->_pNext;
}
}
return 0;
}
Node* AbstractNode::nextSibling() const
{
return _pNext;
}
NamedNodeMap* AbstractNode::attributes() const
{
return 0;
}
Document* AbstractNode::ownerDocument() const
{
return _pOwner;
}
Node* AbstractNode::insertBefore(Node* newChild, Node* refChild)
{
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
}
Node* AbstractNode::replaceChild(Node* newChild, Node* oldChild)
{
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
}
Node* AbstractNode::removeChild(Node* oldChild)
{
throw DOMException(DOMException::NO_MODIFICATION_ALLOWED_ERR);
}
Node* AbstractNode::appendChild(Node* newChild)
{
throw DOMException(DOMException::HIERARCHY_REQUEST_ERR);
}
bool AbstractNode::hasChildNodes() const
{
return false;
}
Node* AbstractNode::cloneNode(bool deep) const
{
return copyNode(deep, _pOwner);
}
void AbstractNode::normalize()
{
}
bool AbstractNode::isSupported(const XMLString& feature, const XMLString& version) const
{
return DOMImplementation::instance().hasFeature(feature, version);
}
const XMLString& AbstractNode::namespaceURI() const
{
return EMPTY_STRING;
}
XMLString AbstractNode::prefix() const
{
return EMPTY_STRING;
}
const XMLString& AbstractNode::localName() const
{
return EMPTY_STRING;
}
bool AbstractNode::hasAttributes() const
{
return false;
}
XMLString AbstractNode::innerText() const
{
return EMPTY_STRING;
}
void AbstractNode::addEventListener(const XMLString& type, EventListener* listener, bool useCapture)
{
if (_pEventDispatcher)
_pEventDispatcher->removeEventListener(type, listener, useCapture);
else
_pEventDispatcher = new EventDispatcher;
_pEventDispatcher->addEventListener(type, listener, useCapture);
}
void AbstractNode::removeEventListener(const XMLString& type, EventListener* listener, bool useCapture)
{
if (_pEventDispatcher)
_pEventDispatcher->removeEventListener(type, listener, useCapture);
}
bool AbstractNode::dispatchEvent(Event* evt)
{
if (eventsSuspended()) return true;
if (evt->type().empty()) throw EventException(EventException::UNSPECIFIED_EVENT_TYPE_ERR);
evt->setTarget(this);
evt->setCurrentPhase(Event::CAPTURING_PHASE);
if (_pParent) _pParent->captureEvent(evt);
if (_pEventDispatcher && !evt->isStopped())
{
evt->setCurrentPhase(Event::AT_TARGET);
evt->setCurrentTarget(this);
_pEventDispatcher->dispatchEvent(evt);
}
if (!evt->isStopped() && evt->bubbles() && _pParent)
{
evt->setCurrentPhase(Event::BUBBLING_PHASE);
_pParent->bubbleEvent(evt);
}
return evt->isCanceled();
}
void AbstractNode::captureEvent(Event* evt)
{
if (_pParent)
_pParent->captureEvent(evt);
if (_pEventDispatcher && !evt->isStopped())
{
evt->setCurrentTarget(this);
_pEventDispatcher->captureEvent(evt);
}
}
void AbstractNode::bubbleEvent(Event* evt)
{
evt->setCurrentTarget(this);
if (_pEventDispatcher)
{
_pEventDispatcher->bubbleEvent(evt);
}
if (_pParent && !evt->isStopped())
_pParent->bubbleEvent(evt);
}
void AbstractNode::dispatchSubtreeModified()
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMSubtreeModified, this, true, false, 0);
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchNodeInserted()
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeInserted, this, true, false, parentNode());
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchNodeRemoved()
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeRemoved, this, true, false, parentNode());
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchNodeRemovedFromDocument()
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeRemovedFromDocument, this, false, false, 0);
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchNodeInsertedIntoDocument()
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMNodeInsertedIntoDocument, this, false, false, 0);
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchAttrModified(Attr* pAttr, MutationEvent::AttrChangeType changeType, const XMLString& prevValue, const XMLString& newValue)
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMAttrModified, this, true, false, pAttr, prevValue, newValue, pAttr->name(), changeType);
dispatchEvent(pEvent.get());
}
void AbstractNode::dispatchCharacterDataModified(const XMLString& prevValue, const XMLString& newValue)
{
AutoPtr<MutationEvent> pEvent = new MutationEvent(_pOwner, MutationEvent::DOMCharacterDataModified, this, true, false, 0, prevValue, newValue, EMPTY_STRING, MutationEvent::MODIFICATION);
dispatchEvent(pEvent.get());
}
bool AbstractNode::events() const
{
return _pOwner->events();
}
bool AbstractNode::eventsSuspended() const
{
return _pOwner->eventsSuspended();
}
void AbstractNode::setOwnerDocument(Document* pOwnerDocument)
{
_pOwner = pOwnerDocument;
}
} } // namespace Poco::XML
namespace XML {
const XMLString Document::NODE_NAME = toXMLString("#document");
Document::Document(NamePool* pNamePool):
AbstractContainerNode(0),
_pDocumentType(0),
_eventSuspendLevel(0)
{
if (pNamePool)
{
_pNamePool = pNamePool;
_pNamePool->duplicate();
}
else
{
_pNamePool = new NamePool;
}
}
Document::Document(DocumentType* pDocumentType, NamePool* pNamePool):
AbstractContainerNode(0),
_pDocumentType(pDocumentType),
_eventSuspendLevel(0)
{
if (pNamePool)
{
_pNamePool = pNamePool;
_pNamePool->duplicate();
}
else
{
_pNamePool = new NamePool;
}
if (_pDocumentType)
{
_pDocumentType->duplicate();
_pDocumentType->setOwnerDocument(this);
}
}
Document::~Document()
{
if (_pDocumentType) _pDocumentType->release();
_pNamePool->release();
}
bool Document::dispatchEvent(Event* evt)
{
return _eventSuspendLevel > 0 || AbstractContainerNode::dispatchEvent(evt);
}
void Document::collectGarbage()
{
_autoReleasePool.release();
}
void Document::suspendEvents()
{
++_eventSuspendLevel;
}
void Document::resumeEvents()
{
poco_assert_dbg (_eventSuspendLevel > 0);
--_eventSuspendLevel;
}
const DOMImplementation& Document::implementation() const
{
return DOMImplementation::instance();
}
Element* Document::documentElement() const
{
// Skip non-element nodes before the document element
Node* pCur = firstChild();
while (pCur)
{
if (dynamic_cast<Element*>(pCur))
return static_cast<Element*>(pCur);
pCur = pCur->nextSibling();
}
return 0;
}
Element* Document::createElement(const XMLString& tagName) const
{
return new Element(const_cast<Document*>(this), EMPTY_STRING, EMPTY_STRING, tagName);
}
DocumentFragment* Document::createDocumentFragment() const
{
return new DocumentFragment(const_cast<Document*>(this));
}
Text* Document::createTextNode(const XMLString& data) const
{
return new Text(const_cast<Document*>(this), data);
}
Comment* Document::createComment(const XMLString& data) const
{
return new Comment(const_cast<Document*>(this), data);
}
CDATASection* Document::createCDATASection(const XMLString& data) const
{
return new CDATASection(const_cast<Document*>(this), data);
}
ProcessingInstruction* Document::createProcessingInstruction(const XMLString& target, const XMLString& data) const
{
return new ProcessingInstruction(const_cast<Document*>(this), target, data);
}
Attr* Document::createAttribute(const XMLString& name) const
{
return new Attr(const_cast<Document*>(this), 0, EMPTY_STRING, EMPTY_STRING, name, EMPTY_STRING);
}
EntityReference* Document::createEntityReference(const XMLString& name) const
{
return new EntityReference(const_cast<Document*>(this), name);
}
NodeList* Document::getElementsByTagName(const XMLString& name) const
{
return new ElementsByTagNameList(const_cast<Document*>(this), name);
}
const XMLString& Document::nodeName() const
{
return NODE_NAME;
}
unsigned short Document::nodeType() const
{
return Node::DOCUMENT_NODE;
}
Node* Document::importNode(Node* importedNode, bool deep)
{
return static_cast<AbstractNode*>(importedNode)->copyNode(deep, this);
}
Element* Document::createElementNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const
{
return new Element(const_cast<Document*>(this), namespaceURI, Name::localName(qualifiedName), qualifiedName);
}
Attr* Document::createAttributeNS(const XMLString& namespaceURI, const XMLString& qualifiedName) const
{
return new Attr(const_cast<Document*>(this), 0, namespaceURI, Name::localName(qualifiedName), qualifiedName, EMPTY_STRING);
}
NodeList* Document::getElementsByTagNameNS(const XMLString& namespaceURI, const XMLString& localName) const
{
return new ElementsByTagNameListNS(const_cast<Document*>(this), namespaceURI, localName);
}
Element* Document::getElementById(const XMLString& elementId) const
{
return 0;
}
Event* Document::createEvent(const XMLString& eventType) const
{
if (eventType == MutationEvent::DOMSubtreeModified ||
eventType == MutationEvent::DOMNodeInserted ||
eventType == MutationEvent::DOMNodeRemoved ||
eventType == MutationEvent::DOMNodeRemovedFromDocument ||
eventType == MutationEvent::DOMNodeInsertedIntoDocument ||
eventType == MutationEvent::DOMAttrModified ||
eventType == MutationEvent::DOMCharacterDataModified)
{
return new MutationEvent(const_cast<Document*>(this), eventType);
}
throw DOMException(DOMException::NOT_SUPPORTED_ERR);
}
Node* Document::copyNode(bool deep, Document* pOwnerDocument) const
{
throw DOMException(DOMException::NOT_SUPPORTED_ERR);
}
void Document::setDoctype(DocumentType* pDoctype)
{
if (_pDocumentType) _pDocumentType->release();
_pDocumentType = pDoctype;
if (_pDocumentType)
{
_pDocumentType->duplicate();
_pDocumentType->setOwnerDocument(this);
}
}
bool Document::eventsSuspended() const
{
return _eventSuspendLevel > 0;
}
bool Document::events() const
{
return _eventSuspendLevel == 0;
}
Entity* Document::createEntity(const XMLString& name, const XMLString& publicId, const XMLString& systemId, const XMLString& notationName) const
{
return new Entity(const_cast<Document*>(this), name, publicId, systemId, notationName);
}
Notation* Document::createNotation(const XMLString& name, const XMLString& publicId, const XMLString& systemId) const
{
return new Notation(const_cast<Document*>(this), name, publicId, systemId);
}
Element* Document::getElementById(const XMLString& elementId, const XMLString& idAttribute) const
{
Element* pElem = documentElement();
if (pElem) pElem = pElem->getElementById(elementId, idAttribute);
return pElem;
}
Element* Document::getElementByIdNS(const XMLString& elementId, const XMLString& idAttributeURI, const XMLString& idAttributeLocalName) const
{
Element* pElem = documentElement();
if (pElem) pElem = pElem->getElementByIdNS(elementId, idAttributeURI, idAttributeLocalName);
return pElem;
}
} } // namespace Poco::XML
TCHAR * CTaskModel::toXMLNoKids()
{
StringBuffer sb;
toXMLString(sb, false);
return sb.toString();
}
TCHAR * CTaskModel::ToXMLString(StringBuffer &sb)
{
return toXMLString(sb, true);
}
