#include <algorithm>
#include <functional>
+#include <boost/lambda/bind.hpp>
+#include <boost/lambda/lambda.hpp>
#include <xercesc/util/XMLUniDefs.hpp>
using namespace xmltooling;
+using namespace xercesc;
+using namespace boost::lambda;
+using namespace boost;
using namespace std;
-using xercesc::chColon;
-using xercesc::DOMAttr;
-using xercesc::DOMElement;
-using xercesc::XMLString;
ElementExtensibleXMLObject::ElementExtensibleXMLObject()
{
{
}
-set<QName> AttributeExtensibleXMLObject::m_idAttributeSet;
+set<xmltooling::QName> AttributeExtensibleXMLObject::m_idAttributeSet;
AttributeExtensibleXMLObject::AttributeExtensibleXMLObject()
{
{
}
-const set<QName>& AttributeExtensibleXMLObject::getRegisteredIDAttributes()
+const set<xmltooling::QName>& AttributeExtensibleXMLObject::getRegisteredIDAttributes()
{
return m_idAttributeSet;
}
-bool AttributeExtensibleXMLObject::isRegisteredIDAttribute(const QName& name)
+bool AttributeExtensibleXMLObject::isRegisteredIDAttribute(const xmltooling::QName& name)
{
return m_idAttributeSet.find(name)!=m_idAttributeSet.end();
}
-void AttributeExtensibleXMLObject::registerIDAttribute(const QName& name)
+void AttributeExtensibleXMLObject::registerIDAttribute(const xmltooling::QName& name)
{
m_idAttributeSet.insert(name);
}
-void AttributeExtensibleXMLObject::deregisterIDAttribute(const QName& name)
+void AttributeExtensibleXMLObject::deregisterIDAttribute(const xmltooling::QName& name)
{
m_idAttributeSet.erase(name);
}
: AbstractXMLObject(src)
{
m_idAttribute = m_attributeMap.end();
- for (map<QName,XMLCh*>::const_iterator i=src.m_attributeMap.begin(); i!=src.m_attributeMap.end(); i++) {
+ for (map<xmltooling::QName,XMLCh*>::const_iterator i = src.m_attributeMap.begin(); i != src.m_attributeMap.end(); ++i) {
m_attributeMap[i->first] = XMLString::replicate(i->second);
}
if (src.m_idAttribute != src.m_attributeMap.end()) {
AbstractAttributeExtensibleXMLObject::~AbstractAttributeExtensibleXMLObject()
{
- for (map<QName,XMLCh*>::iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++)
- XMLString::release(&(i->second));
+ static void (*release)(XMLCh**,MemoryManager*) = &XMLString::release;
+ for_each(
+ m_attributeMap.begin(), m_attributeMap.end(),
+ lambda::bind(
+ release,
+ &lambda::bind(&map<xmltooling::QName,XMLCh*>::value_type::second, boost::ref(_1)),
+ XMLPlatformUtils::fgMemoryManager
+ )
+ );
}
-const XMLCh* AbstractAttributeExtensibleXMLObject::getAttribute(const QName& qualifiedName) const
+const XMLCh* AbstractAttributeExtensibleXMLObject::getAttribute(const xmltooling::QName& qualifiedName) const
{
- map<QName,XMLCh*>::const_iterator i=m_attributeMap.find(qualifiedName);
- return (i==m_attributeMap.end()) ? nullptr : i->second;
+ map<xmltooling::QName,XMLCh*>::const_iterator i = m_attributeMap.find(qualifiedName);
+ return (i != m_attributeMap.end()) ? i->second : nullptr;
}
-void AbstractAttributeExtensibleXMLObject::setAttribute(const QName& qualifiedName, const XMLCh* value, bool ID)
+void AbstractAttributeExtensibleXMLObject::setAttribute(const xmltooling::QName& qualifiedName, const XMLCh* value, bool ID)
{
- map<QName,XMLCh*>::iterator i=m_attributeMap.find(qualifiedName);
- if (i!=m_attributeMap.end()) {
+ map<xmltooling::QName,XMLCh*>::iterator i=m_attributeMap.find(qualifiedName);
+ if (i != m_attributeMap.end()) {
releaseThisandParentDOM();
XMLString::release(&(i->second));
if (value && *value) {
- i->second=XMLString::replicate(value);
+ i->second = XMLString::replicate(value);
if (ID)
- m_idAttribute=i;
+ m_idAttribute = i;
}
else {
- if (m_idAttribute==i)
- m_idAttribute=m_attributeMap.end();
+ if (m_idAttribute == i)
+ m_idAttribute = m_attributeMap.end();
m_attributeMap.erase(i);
}
}
else if (value && *value) {
releaseThisandParentDOM();
- m_attributeMap[qualifiedName]=XMLString::replicate(value);
+ m_attributeMap[qualifiedName] = XMLString::replicate(value);
if (ID)
m_idAttribute = m_attributeMap.find(qualifiedName);
Namespace newNamespace(qualifiedName.getNamespaceURI(), qualifiedName.getPrefix(), false, Namespace::VisiblyUsed);
}
}
-void AttributeExtensibleXMLObject::setAttribute(const QName& qualifiedName, const QName& value)
+void AttributeExtensibleXMLObject::setAttribute(const xmltooling::QName& qualifiedName, const xmltooling::QName& value)
{
if (!value.hasLocalPart())
return;
addNamespace(newNamespace);
}
-const map<QName,XMLCh*>& AbstractAttributeExtensibleXMLObject::getExtensionAttributes() const
+const map<xmltooling::QName,XMLCh*>& AbstractAttributeExtensibleXMLObject::getExtensionAttributes() const
{
return m_attributeMap;
}
const XMLCh* AbstractAttributeExtensibleXMLObject::getXMLID() const
{
- return (m_idAttribute == m_attributeMap.end()) ? nullptr : m_idAttribute->second;
+ return (m_idAttribute != m_attributeMap.end()) ? m_idAttribute->second : nullptr;
}
void AbstractAttributeExtensibleXMLObject::unmarshallExtensionAttribute(const DOMAttr* attribute)
{
- QName q(attribute->getNamespaceURI(),attribute->getLocalName(),attribute->getPrefix());
+ xmltooling::QName q(attribute->getNamespaceURI(), attribute->getLocalName(), attribute->getPrefix());
bool ID = attribute->isId() || isRegisteredIDAttribute(q);
setAttribute(q,attribute->getNodeValue(),ID);
if (ID) {
void AbstractAttributeExtensibleXMLObject::marshallExtensionAttributes(DOMElement* domElement) const
{
- for (map<QName,XMLCh*>::const_iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++) {
- DOMAttr* attr=domElement->getOwnerDocument()->createAttributeNS(i->first.getNamespaceURI(),i->first.getLocalPart());
+ for (map<xmltooling::QName,XMLCh*>::const_iterator i = m_attributeMap.begin(); i != m_attributeMap.end(); ++i) {
+ DOMAttr* attr = domElement->getOwnerDocument()->createAttributeNS(i->first.getNamespaceURI(), i->first.getLocalPart());
if (i->first.hasPrefix())
attr->setPrefix(i->first.getPrefix());
attr->setNodeValue(i->second);
domElement->setAttributeNodeNS(attr);
- if (m_idAttribute==i) {
+ if (m_idAttribute == i) {
#ifdef XMLTOOLING_XERCESC_BOOLSETIDATTRIBUTE
domElement->setIdAttributeNode(attr, true);
#else