2 * Copyright 2001-2006 Internet2
\r
4 * Licensed under the Apache License, Version 2.0 (the "License");
\r
5 * you may not use this file except in compliance with the License.
\r
6 * You may obtain a copy of the License at
\r
8 * http://www.apache.org/licenses/LICENSE-2.0
\r
10 * Unless required by applicable law or agreed to in writing, software
\r
11 * distributed under the License is distributed on an "AS IS" BASIS,
\r
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
13 * See the License for the specific language governing permissions and
\r
14 * limitations under the License.
\r
20 * Abstract interface to objects that can be manipulated in and out of XML form.
\r
23 #if !defined(__xmltooling_xmlobj_h__)
\r
24 #define __xmltooling_xmlobj_h__
\r
29 #include <xercesc/dom/DOM.hpp>
\r
30 #include <xmltooling/QName.h>
\r
31 #include <xmltooling/Namespace.h>
\r
33 using namespace xercesc;
\r
35 #if defined (_MSC_VER)
\r
36 #pragma warning( push )
\r
37 #pragma warning( disable : 4250 4251 )
\r
40 namespace xmltooling {
\r
42 #ifndef XMLTOOLING_NO_XMLSEC
\r
43 class XMLTOOL_API Signature;
\r
44 class XMLTOOL_API SigningContext;
\r
48 * Supplies additional information to the marshalling process.
\r
49 * Currently this only consists of signature related information.
\r
51 class XMLTOOL_API MarshallingContext
\r
53 MAKE_NONCOPYABLE(MarshallingContext);
\r
56 * Default constructor.
\r
58 MarshallingContext() {}
\r
59 ~MarshallingContext() {}
\r
61 #ifndef XMLTOOLING_NO_XMLSEC
\r
63 * Builds a marshalling context with an initial signature/context pair.
\r
65 * @param sig a signature object
\r
66 * @param ctx the signing context to associate with the signature
\r
68 MarshallingContext(Signature* sig, const SigningContext* ctx) {
\r
69 m_signingContexts.push_back(std::make_pair(sig,ctx));
\r
72 /** Array of signing contexts, keyed off of the associated Signature */
\r
73 std::vector< std::pair<Signature*,const SigningContext*> > m_signingContexts;
\r
78 * Object that represents an XML Element that has been unmarshalled into this C++ object.
\r
80 class XMLTOOL_API XMLObject
\r
83 virtual ~XMLObject() {}
\r
86 * Creates a copy of the object, along with all of its children.
\r
88 * The new object tree will be completely distinct and independent of
\r
89 * the original in all respects.
\r
91 virtual XMLObject* clone() const=0;
\r
94 * Gets the QName for this element. This QName <strong>MUST</strong>
\r
95 * contain the namespace URI, namespace prefix, and local element name.
\r
97 * @return constant reference to the QName for this object
\r
99 virtual const QName& getElementQName() const=0;
\r
102 * Gets the namespaces that are scoped to this element.
\r
104 * The caller MUST NOT modify the set returned, but may use any
\r
105 * non-modifying operations or algorithms on it. Iterators will
\r
106 * remain valid unless the set member referenced is removed using
\r
107 * the removeNamespace method.
\r
109 * @return the namespaces that are scoped to this element
\r
111 virtual const std::set<Namespace>& getNamespaces() const=0;
\r
114 * Adds a namespace to the ones already scoped to this element
\r
116 * @param ns the namespace to add
\r
118 virtual void addNamespace(const Namespace& ns) const=0;
\r
121 * Removes a namespace from this element
\r
123 * @param ns the namespace to remove
\r
125 virtual void removeNamespace(const Namespace& ns)=0;
\r
128 * Gets the XML schema type of this element. This translates to contents the xsi:type
\r
129 * attribute for the element.
\r
131 * @return XML schema type of this element
\r
133 virtual const QName* getSchemaType() const=0;
\r
136 * Sets the XML schema type of this element. This translates to contents the xsi:type
\r
137 * attribute for the element.
\r
139 * @param type XML schema type of this element
\r
141 virtual void setSchemaType(const QName* type)=0;
\r
144 * Checks to see if this object has a parent.
\r
146 * @return true if the object has a parent, false if not
\r
148 virtual bool hasParent() const=0;
\r
151 * Gets the parent of this element or null if there is no parent.
\r
153 * @return the parent of this element or null
\r
155 virtual XMLObject* getParent() const=0;
\r
158 * Sets the parent of this element.
\r
160 * @param parent the parent of this element
\r
162 virtual void setParent(XMLObject* parent)=0;
\r
165 * Checks if this XMLObject has children.
\r
167 * @return true if this XMLObject has children, false if not
\r
169 virtual bool hasChildren() const=0;
\r
172 * Returns an unmodifiable list of child objects in the order that they
\r
173 * should appear in the serialized representation.
\r
175 * The validity of the returned list is not maintained if any non-const
\r
176 * operations are performed on the parent object.
\r
178 * @return the list of children
\r
180 virtual const std::list<XMLObject*>& getOrderedChildren() const=0;
\r
183 * Gets the DOM representation of this XMLObject, if one exists.
\r
185 * @return the DOM representation of this XMLObject
\r
187 virtual DOMElement* getDOM() const=0;
\r
190 * Sets the DOM representation of this XMLObject.
\r
192 * @param dom DOM representation of this XMLObject
\r
193 * @param bindDocument true if the object should take ownership of the associated Document
\r
195 virtual void setDOM(DOMElement* dom, bool bindDocument=false) const=0;
\r
198 * Assigns ownership of a DOM document to the XMLObject.
\r
199 * This binds the lifetime of the document to the lifetime of the object.
\r
201 * @param doc DOM document bound to this object
\r
203 virtual void setDocument(DOMDocument* doc) const=0;
\r
206 * Releases the DOM representation of this XMLObject, if there is one.
\r
208 virtual void releaseDOM() const=0;
\r
211 * Releases the DOM representation of this XMLObject's parent.
\r
213 * @param propagateRelease true if all ancestors of this element should release their DOM
\r
215 virtual void releaseParentDOM(bool propagateRelease=true) const=0;
\r
218 * Releases the DOM representation of this XMLObject's children.
\r
220 * @param propagateRelease true if all descendants of this element should release their DOM
\r
222 virtual void releaseChildrenDOM(bool propagateRelease=true) const=0;
\r
225 * A convenience method that is equal to calling releaseDOM() then releaseParentDOM(true).
\r
227 void releaseThisandParentDOM() const {
\r
230 releaseParentDOM(true);
\r
235 * A convenience method that is equal to calling releaseChildrenDOM(true) then releaseDOM().
\r
237 void releaseThisAndChildrenDOM() const {
\r
239 releaseChildrenDOM(true);
\r
245 * Marshalls the XMLObject, and its children, into a DOM element.
\r
246 * If a document is supplied, then it will be used to create the resulting elements.
\r
247 * If the document does not have a Document Element set, then the resulting
\r
248 * element will be set as the Document Element. If no document is supplied, then
\r
249 * a new document will be created and bound to the lifetime of the root object being
\r
250 * marshalled, unless an existing DOM can be reused without creating a new document.
\r
252 * @param document the DOM document the marshalled element will be placed in, or NULL
\r
253 * @param ctx optional marshalling context
\r
254 * @return the DOM element representing this XMLObject
\r
256 * @throws MarshallingException thrown if there is a problem marshalling the given object
\r
257 * @throws SignatureException thrown if a problem occurs during signature creation
\r
259 virtual DOMElement* marshall(DOMDocument* document=NULL, MarshallingContext* ctx=NULL) const=0;
\r
262 * Marshalls the XMLObject and appends it as a child of the given parent element.
\r
264 * <strong>NOTE:</strong> The given Element must be within a DOM tree rooted in
\r
265 * the Document owning the given Element.
\r
267 * @param parentElement the parent element to append the resulting DOM tree
\r
268 * @param ctx optional marshalling context
\r
269 * @return the marshalled element tree
\r
271 * @throws MarshallingException thrown if the given XMLObject can not be marshalled.
\r
272 * @throws SignatureException thrown if a problem occurs during signature creation
\r
274 virtual DOMElement* marshall(DOMElement* parentElement, MarshallingContext* ctx=NULL) const=0;
\r
277 * Unmarshalls the given W3C DOM element into the XMLObject.
\r
278 * The root of a given XML construct should be unmarshalled with the bindDocument parameter
\r
281 * @param element the DOM element to unmarshall
\r
282 * @param bindDocument true iff the resulting XMLObject should take ownership of the DOM's Document
\r
284 * @return the unmarshalled XMLObject
\r
286 * @throws UnmarshallingException thrown if an error occurs unmarshalling the DOM element into the XMLObject
\r
288 virtual XMLObject* unmarshall(DOMElement* element, bool bindDocument=false)=0;
\r
293 XMLObject& operator=(const XMLObject& src);
\r
296 #if defined (_MSC_VER)
\r
297 #pragma warning( pop )
\r
302 #endif /* __xmltooling_xmlobj_h__ */
\r