util/XMLObjectChildrenList.h
valinclude_HEADERS = \
- validation/AbstractValidatingXMLObject.h \
- validation/ValidatingXMLObject.h \
validation/Validator.h \
validation/ValidatorSuite.h
util/ParserPool.cpp \
util/XMLConstants.cpp \
util/XMLHelper.cpp \
- validation/AbstractValidatingXMLObject.cpp \
validation/ValidatorSuite.cpp \
${xmlsec_sources} \
$(thread_sources)
*/
#define BEGIN_XMLOBJECT(linkage,cname,base,desc) \
XMLTOOLING_DOXYGEN(desc) \
- class linkage cname : public virtual base, public virtual xmltooling::ValidatingXMLObject { \
+ class linkage cname : public virtual base { \
protected: \
cname() {} \
public: \
*/
#define BEGIN_XMLOBJECT2(linkage,cname,base,base2,desc) \
XMLTOOLING_DOXYGEN(desc) \
- class linkage cname : public virtual base, public virtual base2, public virtual xmltooling::ValidatingXMLObject { \
+ class linkage cname : public virtual base, public virtual base2 { \
protected: \
cname() {} \
public: \
*/
#define BEGIN_XMLOBJECT3(linkage,cname,base,base2,base3,desc) \
XMLTOOLING_DOXYGEN(desc) \
- class linkage cname : public virtual base, public virtual base2, public virtual base3, \
- public virtual xmltooling::ValidatingXMLObject { \
+ class linkage cname : public virtual base, public virtual base2, public virtual base3 { \
protected: \
cname() {} \
public: \
*/
#define BEGIN_XMLOBJECT4(linkage,cname,base,base2,base3,base4,desc) \
XMLTOOLING_DOXYGEN(desc) \
- class linkage cname : public virtual base, public virtual base2, public virtual base3, \
- public virtual base4, public virtual xmltooling::ValidatingXMLObject { \
+ class linkage cname : public virtual base, public virtual base2, public virtual base3, public virtual base4 { \
protected: \
cname() {} \
public: \
public xmltooling::AbstractSimpleElement, \
public xmltooling::AbstractChildlessElement, \
public xmltooling::AbstractDOMCachingXMLObject, \
- public xmltooling::AbstractValidatingXMLObject, \
public xmltooling::AbstractXMLObjectMarshaller, \
public xmltooling::AbstractXMLObjectUnmarshaller \
{ \
cname##Impl(const cname##Impl& src) \
: xmltooling::AbstractXMLObject(src), \
xmltooling::AbstractSimpleElement(src), \
- xmltooling::AbstractDOMCachingXMLObject(src), \
- xmltooling::AbstractValidatingXMLObject(src) {} \
+ xmltooling::AbstractDOMCachingXMLObject(src) {} \
IMPL_XMLOBJECT_CLONE(cname) \
IMPL_XMLOBJECT_CONTENT \
}
{ \
public: \
virtual ~cname##SchemaValidator() {} \
- virtual cname##SchemaValidator* clone() const { \
- return new cname##SchemaValidator(); \
- } \
virtual void validate(const xmltooling::XMLObject* xmlObject) const { \
const cname* ptr=dynamic_cast<const cname*>(xmlObject); \
if (!ptr) \
{ \
public: \
virtual ~cname##SchemaValidator() {} \
- virtual cname##SchemaValidator* clone() const { \
- return new cname##SchemaValidator(); \
- } \
virtual void validate(const xmltooling::XMLObject* xmlObject) const { \
const cname* ptr=dynamic_cast<const cname*>(xmlObject); \
if (!ptr) \
#include "io/AbstractXMLObjectMarshaller.h"
#include "io/AbstractXMLObjectUnmarshaller.h"
#include "util/XMLHelper.h"
-#include "validation/AbstractValidatingXMLObject.h"
#include <xercesc/util/XMLUniDefs.hpp>
class XMLTOOL_DLLLOCAL EncryptionMethodImpl : public virtual EncryptionMethod,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- EncryptionMethodImpl(const EncryptionMethodImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ EncryptionMethodImpl(const EncryptionMethodImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setAlgorithm(src.getAlgorithm());
if (src.getKeySize())
class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- TransformsImpl(const TransformsImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ TransformsImpl(const TransformsImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
VectorOf(xmlsignature::Transform) v=getTransforms();
for (vector<xmlsignature::Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
if (*i) {
class XMLTOOL_DLLLOCAL CipherReferenceImpl : public virtual CipherReference,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- CipherReferenceImpl(const CipherReferenceImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ CipherReferenceImpl(const CipherReferenceImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setURI(src.getURI());
if (src.getTransforms())
class XMLTOOL_DLLLOCAL CipherDataImpl : public virtual CipherData,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- CipherDataImpl(const CipherDataImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ CipherDataImpl(const CipherDataImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getCipherValue())
setCipherValue(src.getCipherValue()->cloneCipherValue());
public AbstractElementProxy,
public AbstractAttributeExtensibleXMLObject,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(src),
AbstractElementProxy(src),
AbstractAttributeExtensibleXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AbstractDOMCachingXMLObject(src) {
init();
setId(src.getId());
setTarget(src.getTarget());
class XMLTOOL_DLLLOCAL EncryptionPropertiesImpl : public virtual EncryptionProperties,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ EncryptionPropertiesImpl(const EncryptionPropertiesImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setId(src.getId());
VectorOf(EncryptionProperty) v=getEncryptionPropertys();
class XMLTOOL_DLLLOCAL ReferenceTypeImpl : public virtual ReferenceType,
public AbstractElementProxy,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
ReferenceTypeImpl(const ReferenceTypeImpl& src)
- : AbstractXMLObject(src),
- AbstractElementProxy(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractElementProxy(src), AbstractDOMCachingXMLObject(src) {
init();
setURI(src.getURI());
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
class XMLTOOL_DLLLOCAL ReferenceListImpl : public virtual ReferenceList,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- ReferenceListImpl(const ReferenceListImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ ReferenceListImpl(const ReferenceListImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
DataReference* data=dynamic_cast<DataReference*>(*i);
class XMLTOOL_DLLLOCAL EncryptedTypeImpl : public virtual EncryptedType,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- EncryptedTypeImpl(const EncryptedTypeImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ EncryptedTypeImpl(const EncryptedTypeImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setId(src.getId());
setType(src.getType());
#include <xmltooling/SimpleElement.h>
#include <xmltooling/XMLObjectBuilder.h>
#include <xmltooling/util/XMLConstants.h>
-#include <xmltooling/validation/ValidatingXMLObject.h>
#include <xmltooling/validation/ValidatorSuite.h>
#define DECL_XMLSIGOBJECTBUILDER(cname) \
#include <xmltooling/XMLObjectBuilder.h>\r
#include <xmltooling/signature/KeyInfo.h>\r
#include <xmltooling/signature/ContentReference.h>\r
-#include <xmltooling/validation/ValidatingXMLObject.h>\r
#include <xmltooling/util/XMLConstants.h>\r
\r
#include <xsec/dsig/DSIGSignature.hpp>\r
* The default signature settings include Exclusive c14n w/o comments, SHA-1 digests,\r
* and RSA-SHA1 signing. \r
*/\r
- class XMLTOOL_API Signature : public virtual xmltooling::ValidatingXMLObject\r
+ class XMLTOOL_API Signature : public virtual xmltooling::XMLObject\r
{\r
public:\r
virtual ~Signature() {}\r
\r
virtual void validate(const Signature* signature) const;\r
\r
- SignatureValidator* clone() const {\r
- return new SignatureValidator(*this);\r
- }\r
-\r
/**\r
* Replace the current KeyResolver, if any, with a new one.\r
* \r
}\r
\r
protected:\r
- SignatureValidator(const SignatureValidator& src) {\r
- m_resolver=src.m_resolver ? src.m_resolver->clone() : NULL;\r
- }\r
-\r
KeyResolver* m_resolver;\r
};\r
\r
#include "io/AbstractXMLObjectUnmarshaller.h"
#include "signature/KeyInfo.h"
#include "util/XMLHelper.h"
-#include "validation/AbstractValidatingXMLObject.h"
#include <xercesc/util/XMLUniDefs.hpp>
class XMLTOOL_DLLLOCAL DSAKeyValueImpl : public virtual DSAKeyValue,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- DSAKeyValueImpl(const DSAKeyValueImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ DSAKeyValueImpl(const DSAKeyValueImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getP())
setP(src.getP()->cloneP());
class XMLTOOL_DLLLOCAL RSAKeyValueImpl : public virtual RSAKeyValue,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- RSAKeyValueImpl(const RSAKeyValueImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ RSAKeyValueImpl(const RSAKeyValueImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getModulus())
setModulus(src.getModulus()->cloneModulus());
public AbstractSimpleElement,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
KeyValueImpl(const KeyValueImpl& src)
- : AbstractXMLObject(src), AbstractSimpleElement(src),
- AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getDSAKeyValue())
setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
public AbstractDOMCachingXMLObject,
public AbstractElementProxy,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
TransformImpl(const TransformImpl& src)
: AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractElementProxy(src),
- AbstractValidatingXMLObject(src), m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
+ m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
XPath* x=dynamic_cast<XPath*>(*i);
class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- TransformsImpl(const TransformsImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ TransformsImpl(const TransformsImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
VectorOf(Transform) v=getTransforms();
for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
if (*i) {
class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- RetrievalMethodImpl(const RetrievalMethodImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ RetrievalMethodImpl(const RetrievalMethodImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setURI(getURI());
setType(getType());
class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ X509IssuerSerialImpl(const X509IssuerSerialImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getX509IssuerName())
setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- X509DataImpl(const X509DataImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ X509DataImpl(const X509DataImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- SPKIDataImpl(const SPKIDataImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ SPKIDataImpl(const SPKIDataImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
if (i->first) {
class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- PGPDataImpl(const PGPDataImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ PGPDataImpl(const PGPDataImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getPGPKeyID())
setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
public AbstractComplexElement,
public AbstractSimpleElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
KeyInfoImpl(const KeyInfoImpl& src)
- : AbstractXMLObject(src),
- AbstractSimpleElement(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src),
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src),
m_Id(XMLString::replicate(src.m_Id)) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
#include "util/NDC.h"\r
#include "util/XMLConstants.h"\r
#include "util/XMLHelper.h"\r
-#include "validation/ValidatingXMLObject.h"\r
\r
#include <log4cpp/Category.hh>\r
#include <xercesc/framework/MemBufInputSource.hpp>\r
\r
namespace xmlsignature {\r
\r
- class XMLTOOL_DLLLOCAL XMLSecSignatureImpl\r
- : public UnknownElementImpl, public virtual Signature, public virtual ValidatingXMLObject\r
+ class XMLTOOL_DLLLOCAL XMLSecSignatureImpl : public UnknownElementImpl, public virtual Signature\r
{\r
public:\r
XMLSecSignatureImpl() : UnknownElementImpl(XMLConstants::XMLSIG_NS, Signature::LOCAL_NAME, XMLConstants::XMLSIG_PREFIX),\r
\r
void sign();\r
\r
- void registerValidator(Validator* validator);\r
- void deregisterValidator(Validator* validator);\r
- void deregisterAll();\r
- void validate(bool validateDescendants) const;\r
-\r
private:\r
mutable DSIGSignature* m_signature;\r
XMLCh* m_c14n;\r
XSECCryptoKey* m_key;\r
KeyInfo* m_keyInfo;\r
ContentReference* m_reference;\r
- vector<Validator*> m_validators;\r
};\r
\r
};\r
delete m_key;\r
delete m_keyInfo;\r
delete m_reference;\r
- for_each(m_validators.begin(),m_validators.end(),cleanup<Validator>());\r
}\r
\r
void XMLSecSignatureImpl::releaseDOM() const\r
if (m_keyInfo)\r
ret->m_keyInfo=m_keyInfo->cloneKeyInfo();\r
\r
- xmltooling::clone(m_validators,ret->m_validators);\r
-\r
// If there's no XML locally, serialize this object into the new one, otherwise just copy it over.\r
if (m_xml.empty())\r
serialize(ret->m_xml);\r
return this;\r
}\r
\r
-void XMLSecSignatureImpl::registerValidator(Validator* validator)\r
-{\r
- m_validators.push_back(validator);\r
-}\r
-\r
-void XMLSecSignatureImpl::deregisterValidator(Validator* validator)\r
-{\r
- for (vector<Validator*>::iterator i=m_validators.begin(); i!=m_validators.end(); i++) {\r
- if ((*i)==validator) {\r
- m_validators.erase(i);\r
- return;\r
- }\r
- }\r
-}\r
-\r
-void XMLSecSignatureImpl::deregisterAll()\r
-{\r
- for_each(m_validators.begin(),m_validators.end(),cleanup<Validator>());\r
- m_validators.clear();\r
-}\r
-\r
-class _validate : public binary_function<const XMLObject*,bool,void> {\r
-public:\r
- void operator()(const XMLObject* obj, bool propagate) const {\r
- const ValidatingXMLObject* val = dynamic_cast<const ValidatingXMLObject*>(obj);\r
- if (val) {\r
- val->validate(propagate);\r
- }\r
- }\r
-};\r
-\r
-void XMLSecSignatureImpl::validate(bool validateDescendants) const\r
-{\r
- for_each(\r
- m_validators.begin(),m_validators.end(),\r
- bind2nd(mem_fun<void,Validator,const XMLObject*>(&Validator::validate),this)\r
- );\r
- \r
- if (validateDescendants && m_keyInfo) {\r
- m_keyInfo->validate(validateDescendants);\r
- }\r
-}\r
-\r
Signature* SignatureBuilder::buildObject(\r
const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType\r
) const\r
+++ /dev/null
-/*\r
- * Copyright 2001-2006 Internet2\r
- * \r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-/**\r
- * AbstractValidatingXMLObject.cpp\r
- * \r
- * Extension of AbstractXMLObject that implements a ValidatingXMLObject. \r
- */\r
-\r
-#include "internal.h"\r
-#include "exceptions.h"\r
-#include "validation/AbstractValidatingXMLObject.h"\r
-\r
-#include <algorithm>\r
-#include <functional>\r
-\r
-using namespace xmltooling;\r
-using namespace std;\r
-\r
-AbstractValidatingXMLObject::ValidatorWrapper::~ValidatorWrapper()\r
-{\r
- for_each(v.begin(),v.end(),cleanup<Validator>());\r
-}\r
-\r
-AbstractValidatingXMLObject::AbstractValidatingXMLObject(const AbstractValidatingXMLObject& src)\r
- : AbstractXMLObject(src), m_validators(NULL)\r
-{\r
- if (src.m_validators) {\r
- m_validators=new ValidatorWrapper();\r
- xmltooling::clone(src.m_validators->v,m_validators->v);\r
- }\r
-}\r
-\r
-AbstractValidatingXMLObject::~AbstractValidatingXMLObject()\r
-{\r
- delete m_validators;\r
-}\r
-\r
-void AbstractValidatingXMLObject::registerValidator(Validator* validator)\r
-{\r
- if (!m_validators)\r
- m_validators=new ValidatorWrapper();\r
- m_validators->v.push_back(validator);\r
-}\r
-\r
-void AbstractValidatingXMLObject::deregisterValidator(Validator* validator)\r
-{\r
- if (m_validators) {\r
- for (std::vector<Validator*>::iterator i=m_validators->v.begin(); i!=m_validators->v.end(); i++) {\r
- if ((*i)==validator) {\r
- m_validators->v.erase(i);\r
- return;\r
- }\r
- }\r
- }\r
-}\r
-\r
-void AbstractValidatingXMLObject::deregisterAll()\r
-{\r
- delete m_validators;\r
- m_validators=NULL;\r
-}\r
-\r
-class _validate : public binary_function<const XMLObject*,bool,void> {\r
-public:\r
- void operator()(const XMLObject* obj, bool propagate) const {\r
- const ValidatingXMLObject* val = dynamic_cast<const ValidatingXMLObject*>(obj);\r
- if (val) {\r
- val->validate(propagate);\r
- }\r
- }\r
-};\r
-\r
-void AbstractValidatingXMLObject::validate(bool validateDescendants) const\r
-{\r
- if (m_validators) {\r
- for_each(\r
- m_validators->v.begin(),m_validators->v.end(),\r
- bind2nd(mem_fun<void,Validator,const XMLObject*>(&Validator::validate),this)\r
- );\r
- }\r
- \r
- if (validateDescendants && hasChildren()) {\r
- const list<XMLObject*>& children=getOrderedChildren();\r
- for_each(children.begin(),children.end(),bind2nd(_validate(),validateDescendants));\r
- }\r
-}\r
+++ /dev/null
-/*\r
- * Copyright 2001-2006 Internet2\r
- * \r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-/**\r
- * @file AbstractValidatingXMLObject.h\r
- * \r
- * Extension of AbstractXMLObject that implements a ValidatingXMLObject. \r
- */\r
-\r
-#if !defined(__xmltooling_abstractvalxmlobj_h__)\r
-#define __xmltooling_abstractvalxmlobj_h__\r
-\r
-#include <xmltooling/AbstractXMLObject.h>\r
-#include <xmltooling/validation/ValidatingXMLObject.h>\r
-\r
-#if defined (_MSC_VER)\r
- #pragma warning( push )\r
- #pragma warning( disable : 4250 4251 )\r
-#endif\r
-\r
-namespace xmltooling {\r
-\r
- /**\r
- * Extension of AbstractXMLObject that implements a ValidatingXMLObject.\r
- */\r
- class XMLTOOL_API AbstractValidatingXMLObject : public virtual AbstractXMLObject, public virtual ValidatingXMLObject\r
- {\r
- public:\r
- virtual ~AbstractValidatingXMLObject();\r
- \r
- /**\r
- * @see ValidatingXMLObject::registerValidator()\r
- */\r
- void registerValidator(Validator* validator);\r
- \r
- /**\r
- * @see ValidatingXMLObject::deregisterValidator()\r
- */\r
- void deregisterValidator(Validator* validator);\r
-\r
- /**\r
- * @see ValidatingXMLObject::deregisterAll()\r
- */\r
- void deregisterAll();\r
- \r
- /**\r
- * @see ValidatingXMLObject::validate()\r
- */\r
- void validate(bool validateDescendants) const;\r
-\r
- protected:\r
- AbstractValidatingXMLObject() : m_validators(NULL) {}\r
-\r
- /** Copy constructor. */\r
- AbstractValidatingXMLObject(const AbstractValidatingXMLObject& src);\r
-\r
- private:\r
- struct XMLTOOL_DLLLOCAL ValidatorWrapper {\r
- ~ValidatorWrapper(); \r
- std::vector<Validator*> v;\r
- };\r
- \r
- mutable ValidatorWrapper* m_validators;\r
- };\r
- \r
-};\r
-\r
-#if defined (_MSC_VER)\r
- #pragma warning( pop )\r
-#endif\r
-\r
-#endif /* __xmltooling_abstractvalxmlobj_h__ */\r
+++ /dev/null
-/*\r
- * Copyright 2001-2006 Internet2\r
- * \r
- * Licensed under the Apache License, Version 2.0 (the "License");\r
- * you may not use this file except in compliance with the License.\r
- * You may obtain a copy of the License at\r
- *\r
- * http://www.apache.org/licenses/LICENSE-2.0\r
- *\r
- * Unless required by applicable law or agreed to in writing, software\r
- * distributed under the License is distributed on an "AS IS" BASIS,\r
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- * See the License for the specific language governing permissions and\r
- * limitations under the License.\r
- */\r
-\r
-/**\r
- * @file ValidatingXMLObject.h\r
- * \r
- * An XMLObject that can evaluate per-object validation rules. \r
- */\r
-\r
-#if !defined(__xmltooling_valxmlobj_h__)\r
-#define __xmltooling_valxmlobj_h__\r
-\r
-#include <vector>\r
-#include <xmltooling/XMLObject.h>\r
-#include <xmltooling/validation/Validator.h>\r
-\r
-#if defined (_MSC_VER)\r
- #pragma warning( push )\r
- #pragma warning( disable : 4250 4251 )\r
-#endif\r
-\r
-namespace xmltooling {\r
-\r
- /**\r
- * A functional interface for XMLObjects that offer the ability\r
- * to evaluate validation rules defined per-object.\r
- */\r
- class XMLTOOL_API ValidatingXMLObject : public virtual XMLObject\r
- {\r
- protected:\r
- ValidatingXMLObject() {}\r
- \r
- public:\r
- virtual ~ValidatingXMLObject() {}\r
- \r
- /**\r
- * Registers a validator for this XMLObject.\r
- * \r
- * @param validator the validator\r
- */\r
- virtual void registerValidator(Validator* validator)=0;\r
- \r
- /**\r
- * Deregisters a validator for this XMLObject.\r
- * \r
- * @param validator the validator\r
- */\r
- virtual void deregisterValidator(Validator* validator)=0;\r
-\r
- /**\r
- * Deregisters all validators for this XMLObject.\r
- */\r
- virtual void deregisterAll()=0;\r
- \r
- /**\r
- * Validates this XMLObject against all registered validators.\r
- * \r
- * @param validateDescendants true if all the descendants of this object should \r
- * be validated as well, false if not\r
- * \r
- * @throws ValidationException thrown if the object is not valid\r
- */\r
- virtual void validate(bool validateDescendants) const=0;\r
- };\r
- \r
-};\r
-\r
-#if defined (_MSC_VER)\r
- #pragma warning( pop )\r
-#endif\r
-\r
-#endif /* __xmltooling_valxmlobj_h__ */\r
*/\r
virtual void validate(const XMLObject* xmlObject) const=0;\r
\r
- /**\r
- * Returns a copy of the validator.\r
- *\r
- * @return the new validator\r
- */\r
- virtual Validator* clone() const=0;\r
-\r
protected:\r
Validator() {}\r
};\r
Name="validation"\r
>\r
<File\r
- RelativePath=".\validation\AbstractValidatingXMLObject.cpp"\r
- >\r
- </File>\r
- <File\r
RelativePath=".\validation\ValidatorSuite.cpp"\r
>\r
</File>\r
Name="validation"\r
>\r
<File\r
- RelativePath=".\validation\AbstractValidatingXMLObject.h"\r
- >\r
- </File>\r
- <File\r
- RelativePath=".\validation\ValidatingXMLObject.h"\r
- >\r
- </File>\r
- <File\r
RelativePath=".\validation\Validator.h"\r
>\r
</File>\r
{\r
XMLCh* m_uri;\r
\r
- TestValidator(const TestValidator& src) : SignatureValidator(src) {\r
- m_uri=XMLString::replicate(src.m_uri);\r
- }\r
-\r
public:\r
TestValidator(const XMLCh* uri, XSECCryptoKey* key) : SignatureValidator(new KeyResolver(key)) {\r
m_uri=XMLString::replicate(uri);\r
XMLString::release(&m_uri);\r
}\r
\r
- TestValidator* clone() const {\r
- return new TestValidator(*this);\r
- }\r
-\r
void validate(const Signature* sigObj) const {\r
DSIGSignature* sig=sigObj->getXMLSignature();\r
if (!sig)\r
auto_ptr<SimpleXMLObject> sxObject2(dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc)));\r
TS_ASSERT(sxObject2.get()!=NULL);\r
TS_ASSERT(sxObject2->getSignature()!=NULL);\r
- sxObject2->getSignature()->registerValidator(new TestValidator(&chNull,m_key->clone()));\r
\r
try {\r
- sxObject2->getSignature()->validate(false);\r
+ TestValidator tv(&chNull,m_key->clone());\r
+ tv.validate(sxObject2->getSignature());\r
}\r
catch (XMLToolingException& e) {\r
TS_TRACE(e.what());\r
<?xml version="1.0" encoding="UTF-8"?>
-<products>
+<products xmlns:p="http://example.com/product-info">
<product id="1144" xmlns="http://example.com/product-info">
<name xml:lang="en">Python Perfect IDE</name>
<description>
the year 3000. Works well with <code>1166</code>.
</description>
</product>
- <p:product id="1166" xmlns:p="http://example.com/product-info">
+ <p:product id="1166">
<p:name>XSLT Perfect IDE</p:name>
<p:description>
<p:code>red</p:code>
projects / shibboleth / cpp-xmltooling.git / commitdiff