X-Git-Url: http://www.project-moonshot.org/gitweb/?p=shibboleth%2Fcpp-xmltooling.git;a=blobdiff_plain;f=xmltoolingtest%2FXMLObjectBaseTestCase.h;h=c51a4ffd4a4ff83cce551ef4f247264da095c09e;hp=18d02d55aadcdc98d4bcf23f996f8e55993aba6b;hb=HEAD;hpb=e48e1c0c331276a2c312cc798809a11385badc13 diff --git a/xmltoolingtest/XMLObjectBaseTestCase.h b/xmltoolingtest/XMLObjectBaseTestCase.h index 18d02d5..c51a4ff 100644 --- a/xmltoolingtest/XMLObjectBaseTestCase.h +++ b/xmltoolingtest/XMLObjectBaseTestCase.h @@ -1,41 +1,48 @@ -/* - * Copyright 2001-2005 Internet2 - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at +/** + * Licensed to the University Corporation for Advanced Internet + * Development, Inc. (UCAID) under one or more contributor license + * agreements. See the NOTICE file distributed with this work for + * additional information regarding copyright ownership. * - * http://www.apache.org/licenses/LICENSE-2.0 + * UCAID licenses this file to you under the Apache License, + * Version 2.0 (the "License"); you may not use this file except + * in compliance with the License. You may obtain a copy of the + * License at * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, + * either express or implied. See the License for the specific + * language governing permissions and limitations under the License. */ #include #include -#include -#include +#include +#include #include #include #include #include #include -#ifndef XMLTOOLING_NO_XMLSEC - #include -#endif +#include +#include #include #include #include #include +#ifndef XMLTOOLING_NO_XMLSEC + #include + using namespace xmlsignature; +#endif + using namespace xmltooling; +using namespace xercesc; using namespace std; -extern ParserPool* validatingPool; -extern ParserPool* nonvalidatingPool; extern string data_path; #if defined (_MSC_VER) @@ -43,31 +50,65 @@ extern string data_path; #pragma warning( disable : 4250 4251 ) #endif -class SimpleXMLObject : public AbstractDOMCachingXMLObject +class SimpleXMLObject + : public AbstractAttributeExtensibleXMLObject, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller { +protected: + SimpleXMLObject(const SimpleXMLObject& src) + : AbstractXMLObject(src), AbstractAttributeExtensibleXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), + m_id(XMLString::replicate(src.m_id)) { +#ifndef XMLTOOLING_NO_XMLSEC + m_children.push_back(nullptr); + m_signature=m_children.begin(); +#endif + VectorOf(SimpleXMLObject) mine=getSimpleXMLObjects(); + for (vector::const_iterator i=src.m_simples.begin(); i!=src.m_simples.end(); i++) { + mine.push_back(dynamic_cast((*i)->clone())); + } + } + public: static const XMLCh NAMESPACE[]; static const XMLCh NAMESPACE_PREFIX[]; static const XMLCh LOCAL_NAME[]; + static const XMLCh DERIVED_NAME[]; + static const XMLCh TYPE_NAME[]; static const XMLCh ID_ATTRIB_NAME[]; - SimpleXMLObject() : AbstractDOMCachingXMLObject(NAMESPACE, LOCAL_NAME, NAMESPACE_PREFIX), m_id(NULL), m_value(NULL) { + SimpleXMLObject( + const XMLCh* nsURI=nullptr, const XMLCh* localName=nullptr, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr + ) : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_id(nullptr) { #ifndef XMLTOOLING_NO_XMLSEC - m_children.push_back(NULL); + m_children.push_back(nullptr); m_signature=m_children.begin(); #endif } virtual ~SimpleXMLObject() { XMLString::release(&m_id); - XMLString::release(&m_value); } - + + XMLObject* clone() const { + auto_ptr domClone(AbstractDOMCachingXMLObject::clone()); + SimpleXMLObject* ret=dynamic_cast(domClone.get()); + if (ret) { + domClone.release(); + return ret; + } + + return new SimpleXMLObject(*this); + } + + const XMLCh* getXMLID() const { return getId(); } const XMLCh* getId() const { return m_id; } void setId(const XMLCh* id) { m_id=prepareForAssignment(m_id,id); } - const XMLCh* getValue() const { return m_value; } - void setValue(const XMLCh* value) { m_value=prepareForAssignment(m_value,value); } + const XMLCh* getValue() const { return getTextContent(); } + void setValue(const XMLCh* value) { setTextContent(value); } #ifndef XMLTOOLING_NO_XMLSEC Signature* getSignature() const { @@ -83,204 +124,78 @@ public: return VectorOf(SimpleXMLObject)(this, m_simples, &m_children, m_children.end()); } - SimpleXMLObject* clone() const { - auto_ptr domClone(AbstractDOMCachingXMLObject::clone()); - SimpleXMLObject* ret=dynamic_cast(domClone.get()); - if (ret) { - domClone.release(); - return ret; + const std::vector& getSimpleXMLObjects() const { + return m_simples; + } + +protected: + void marshallAttributes(xercesc::DOMElement* domElement) const { + if(getId()) { + domElement->setAttributeNS(nullptr, SimpleXMLObject::ID_ATTRIB_NAME, getId()); +#ifdef XMLTOOLING_XERCESC_BOOLSETIDATTRIBUTE + domElement->setIdAttributeNS(nullptr, SimpleXMLObject::ID_ATTRIB_NAME, true); +#else + domElement->setIdAttributeNS(nullptr, SimpleXMLObject::ID_ATTRIB_NAME); +#endif } - - ret=new SimpleXMLObject(); - ret->m_namespaces=m_namespaces; - ret->setId(m_id); - ret->setValue(m_value); - xmltooling::clone(m_children, ret->m_children); - return ret; + marshallExtensionAttributes(domElement); } -private: - XMLCh* m_id; - XMLCh* m_value; - vector m_simples; + void processChildElement(XMLObject* childXMLObject, const xercesc::DOMElement* root) { + SimpleXMLObject* simple=dynamic_cast(childXMLObject); + if (simple) { + getSimpleXMLObjects().push_back(simple); + return; + } + #ifndef XMLTOOLING_NO_XMLSEC - list::iterator m_signature; + Signature* sig=dynamic_cast(childXMLObject); + if (sig) { + setSignature(sig); + return; + } #endif -}; - -class SimpleXMLObjectBuilder : public XMLObjectBuilder -{ -public: - SimpleXMLObject* buildObject() const { - return new SimpleXMLObject(); - } -}; -class SimpleXMLObjectMarshaller : public AbstractXMLObjectMarshaller -{ -public: - SimpleXMLObjectMarshaller() {} - -private: - void marshallAttributes(const XMLObject& xmlObject, DOMElement* domElement) const { - const SimpleXMLObject& simpleXMLObject = dynamic_cast(xmlObject); - - if(simpleXMLObject.getId()) { - domElement->setAttributeNS(NULL, SimpleXMLObject::ID_ATTRIB_NAME, simpleXMLObject.getId()); - domElement->setIdAttributeNS(NULL, SimpleXMLObject::ID_ATTRIB_NAME); - } + throw UnmarshallingException("Unknown child element cannot be added to parent object."); } - void marshallElementContent(const XMLObject& xmlObject, DOMElement* domElement) const { - const SimpleXMLObject& simpleXMLObject = dynamic_cast(xmlObject); - - if(simpleXMLObject.getValue()) { - domElement->setTextContent(simpleXMLObject.getValue()); + void processAttribute(const xercesc::DOMAttr* attribute) { + if (XMLHelper::isNodeNamed(attribute, nullptr, SimpleXMLObject::ID_ATTRIB_NAME)) { + setId(attribute->getValue()); + return; } + unmarshallExtensionAttribute(attribute); } -}; - -class SimpleXMLObjectUnmarshaller : public AbstractXMLObjectUnmarshaller -{ -public: - SimpleXMLObjectUnmarshaller() {} private: - void processChildElement(XMLObject& parentXMLObject, XMLObject* childXMLObject, const DOMElement* root) const { - SimpleXMLObject& simpleXMLObject = dynamic_cast(parentXMLObject); - - if (XMLHelper::isNodeNamed(root, SimpleXMLObject::NAMESPACE, SimpleXMLObject::LOCAL_NAME)) - simpleXMLObject.getSimpleXMLObjects().push_back(dynamic_cast(childXMLObject)); + XMLCh* m_id; + vector m_simples; #ifndef XMLTOOLING_NO_XMLSEC - else if (XMLHelper::isNodeNamed(root, XMLConstants::XMLSIG_NS, Signature::LOCAL_NAME)) - simpleXMLObject.setSignature(dynamic_cast(childXMLObject)); + list::iterator m_signature; #endif - else - throw UnmarshallingException("Unknown child element cannot be added to parent object."); - } - - void processAttribute(XMLObject& xmlObject, const DOMAttr* attribute) const { - SimpleXMLObject& simpleXMLObject = dynamic_cast(xmlObject); - - if (XMLHelper::isNodeNamed(attribute, NULL, SimpleXMLObject::ID_ATTRIB_NAME)) - simpleXMLObject.setId(attribute->getValue()); - else - throw UnmarshallingException("Unknown attribute cannot be processed by parent object."); - } - - void processElementContent(XMLObject& xmlObject, const XMLCh* elementContent) const { - SimpleXMLObject& simpleXMLObject = dynamic_cast(xmlObject); - - simpleXMLObject.setValue(elementContent); - } - -}; - -class WildcardXMLObjectMarshaller; - -class WildcardXMLObject : public AbstractElementProxy, public AbstractAttributeExtensibleXMLObject -{ - friend class WildcardXMLObjectMarshaller; -public: - WildcardXMLObject(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix) - : AbstractDOMCachingXMLObject(nsURI, localName, prefix), - AbstractElementProxy(nsURI, localName, prefix), - AbstractAttributeExtensibleXMLObject(nsURI, localName, prefix) {} - virtual ~WildcardXMLObject() {} - - WildcardXMLObject* clone() const { - auto_ptr domClone(AbstractDOMCachingXMLObject::clone()); - WildcardXMLObject* ret=dynamic_cast(domClone.get()); - if (ret) { - domClone.release(); - return ret; - } - - ret=new WildcardXMLObject( - getElementQName().getNamespaceURI(),getElementQName().getLocalPart(),getElementQName().getPrefix() - ); - ret->m_namespaces=m_namespaces; - for (map::const_iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++) { - ret->m_attributeMap[i->first]=XMLString::replicate(i->second); - } - ret->setTextContent(getTextContent()); - xmltooling::clone(m_children, ret->m_children); - return ret; - } }; -class WildcardXMLObjectBuilder : public XMLObjectBuilder +class SimpleXMLObjectBuilder : public XMLObjectBuilder { public: XMLObject* buildObject() const { - throw XMLObjectException("No default builder available."); + return buildObject(SimpleXMLObject::NAMESPACE, SimpleXMLObject::LOCAL_NAME, SimpleXMLObject::NAMESPACE_PREFIX); } - WildcardXMLObject* buildObject(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix) const { - return new WildcardXMLObject(nsURI,localName,prefix); + XMLObject* buildObject( + const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=nullptr, const xmltooling::QName* schemaType=nullptr + ) const { + return new SimpleXMLObject(nsURI, localName, prefix, schemaType); } -}; - -class WildcardXMLObjectMarshaller : public AbstractXMLObjectMarshaller -{ -public: - WildcardXMLObjectMarshaller() : AbstractXMLObjectMarshaller() {} - -private: - void marshallAttributes(const XMLObject& xmlObject, DOMElement* domElement) const { - const WildcardXMLObject& wcXMLObject = dynamic_cast(xmlObject); - - for (map::const_iterator i=wcXMLObject.m_attributeMap.begin(); i!=wcXMLObject.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->setAttributeNode(attr); - } - } - - void marshallElementContent(const XMLObject& xmlObject, DOMElement* domElement) const { - const WildcardXMLObject& wcXMLObject = dynamic_cast(xmlObject); - - if(wcXMLObject.getTextContent()) { - domElement->appendChild(domElement->getOwnerDocument()->createTextNode(wcXMLObject.getTextContent())); - } - } -}; -class WildcardXMLObjectUnmarshaller : public AbstractXMLObjectUnmarshaller -{ -public: - WildcardXMLObjectUnmarshaller() {} - -private: - XMLObject* buildXMLObject(const DOMElement* domElement) const { - const WildcardXMLObjectBuilder* builder = - dynamic_cast(XMLObjectBuilder::getBuilder(domElement)); - if (builder) - return builder->buildObject(domElement->getNamespaceURI(),domElement->getLocalName(),domElement->getPrefix()); - throw UnmarshallingException("Failed to locate WildcardObjectBuilder for element."); - } - - void processChildElement(XMLObject& parentXMLObject, XMLObject* childXMLObject, const DOMElement* root) const { - WildcardXMLObject& wcXMLObject = dynamic_cast(parentXMLObject); - - wcXMLObject.getXMLObjects().push_back(childXMLObject); - } - - void processAttribute(XMLObject& xmlObject, const DOMAttr* attribute) const { - WildcardXMLObject& wcXMLObject = dynamic_cast(xmlObject); - - QName q(attribute->getNamespaceURI(),attribute->getLocalName(),attribute->getPrefix()); - wcXMLObject.setAttribute(q,attribute->getNodeValue()); - } - - void processElementContent(XMLObject& xmlObject, const XMLCh* elementContent) const { - WildcardXMLObject& wcXMLObject = dynamic_cast(xmlObject); - - wcXMLObject.setTextContent(elementContent); + static SimpleXMLObject* buildSimpleXMLObject() { + const SimpleXMLObjectBuilder* b = dynamic_cast( + XMLObjectBuilder::getBuilder(xmltooling::QName(SimpleXMLObject::NAMESPACE,SimpleXMLObject::LOCAL_NAME)) + ); + if (b) + return dynamic_cast(b->buildObject()); + throw XMLObjectException("Unable to obtain typed builder for SimpleXMLObject."); } - }; #if defined (_MSC_VER)