csharp-to-cpp/apireference/xml__schema__validator_8h_source.html

#pragma once


#include <xml/xml_char_type.h>

#include <xml/schema/xml_schema_validation_flags.h>

#include <xml/schema/validation_event_handler.h>

#include <system/multicast_delegate.h>

#include <system/exceptions.h>

#include <system/enum_helpers.h>

#include <system/array.h>

#include <cstdint>


namespace System

{

namespace Collections

{

namespace Generic

{

template <typename, typename> class Dictionary;

template <typename> class List;

} // namespace Generic

} // namespace Collections

namespace Text

{

class StringBuilder;

} // namespace Text

class Uri;

namespace Xml

{

class DocumentSchemaValidator;

class HWStack;

class IDtdInfo;

class IXmlLineInfo;

class IXmlNamespaceResolver;

namespace Schema

{

class BaseValidator;

class DtdValidator;

class IdRefNode;

class SchemaAttDef;

class SchemaDeclBase;

class SchemaElementDecl;

class SchemaInfo;

class ValidationState;

enum class ValidatorState;

class XdrValidator;

class XmlSchema;

class XmlSchemaAttribute;

enum class XmlSchemaContentProcessing;

enum class XmlSchemaContentType;

class XmlSchemaDatatype;

class XmlSchemaElement;

class Details_XmlSchemaException; using XmlSchemaException = System::ExceptionWrapper<Details_XmlSchemaException>;

class XmlSchemaInfo;

class XmlSchemaObject;

class XmlSchemaParticle;

class XmlSchemaSet;

class XmlSchemaSimpleType;

class Details_XmlSchemaValidationException; using XmlSchemaValidationException = System::ExceptionWrapper<Details_XmlSchemaValidationException>;

enum class XmlSeverityType;

class XsdValidator;

} // namespace Schema

class XmlNameTable;

class XmlQualifiedName;

class XmlResolver;

enum class XmlTokenizedType;

class XsdValidatingReader;

} // namespace Xml

} // namespace System


namespace System {


namespace Xml {


namespace Schema {


using XmlValueGetter = System::MulticastDelegate<SharedPtr<Object>()>;


class ASPOSECPP_SHARED_CLASS XmlSchemaValidator final : public System::Object

{

    typedef XmlSchemaValidator ThisType;

    typedef System::Object BaseType;


    typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;

    ASPOSECPP_SHARED_RTTI_INFO_DECL();


public:


    using Ptr = SharedPtr<XmlSchemaValidator>;


private:

    friend class System::Xml::XsdValidatingReader;

    friend class System::Xml::DocumentSchemaValidator;

    friend class BaseValidator;

    friend class DtdValidator;

    friend class XdrValidator;

    friend class XsdValidator;


public:


    System::Xml::Schema::ValidationEventHandler ValidationEventHandler;


    ASPOSECPP_SHARED_API void set_XmlResolver(const SharedPtr<System::Xml::XmlResolver>& value);

    ASPOSECPP_SHARED_API SharedPtr<IXmlLineInfo> get_LineInfoProvider();

    ASPOSECPP_SHARED_API void set_LineInfoProvider(const SharedPtr<IXmlLineInfo>& value);

    ASPOSECPP_SHARED_API SharedPtr<Uri> get_SourceUri();

    ASPOSECPP_SHARED_API void set_SourceUri(const SharedPtr<Uri>& value);

    ASPOSECPP_SHARED_API SharedPtr<Object> get_ValidationEventSender();

    ASPOSECPP_SHARED_API void set_ValidationEventSender(const SharedPtr<Object>& value);


    ASPOSECPP_SHARED_API XmlSchemaValidator(const SharedPtr<XmlNameTable>& nameTable, const SharedPtr<XmlSchemaSet>& schemas, const SharedPtr<IXmlNamespaceResolver>& namespaceResolver, XmlSchemaValidationFlags validationFlags);


    ASPOSECPP_SHARED_API void AddSchema(const SharedPtr<XmlSchema>& schema);

    ASPOSECPP_SHARED_API void Initialize();

    ASPOSECPP_SHARED_API void Initialize(const SharedPtr<XmlSchemaObject>& partialValidationType);

    ASPOSECPP_SHARED_API void ValidateElement(const String& localName, const String& namespaceUri, const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API void ValidateElement(const String& localName, const String& namespaceUri, const SharedPtr<XmlSchemaInfo>& schemaInfo, const String& xsiType, const String& xsiNil, const String& xsiSchemaLocation, const String& xsiNoNamespaceSchemaLocation);

    ASPOSECPP_SHARED_API SharedPtr<Object> ValidateAttribute(const String& localName, const String& namespaceUri, const String& attributeValue, const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API SharedPtr<Object> ValidateAttribute(const String& localName, const String& namespaceUri, XmlValueGetter attributeValue, const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API void GetUnspecifiedDefaultAttributes(const SharedPtr<Collections::Generic::List<SharedPtr<Object>>>& defaultAttributes);

    ASPOSECPP_SHARED_API void ValidateEndOfAttributes(const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API void ValidateText(const String& elementValue);

    ASPOSECPP_SHARED_API void ValidateText(XmlValueGetter elementValue);

    ASPOSECPP_SHARED_API void ValidateWhitespace(const String& elementValue);

    ASPOSECPP_SHARED_API void ValidateWhitespace(XmlValueGetter elementValue);

    ASPOSECPP_SHARED_API SharedPtr<Object> ValidateEndElement(const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API SharedPtr<Object> ValidateEndElement(const SharedPtr<XmlSchemaInfo>& schemaInfo, const SharedPtr<Object>& typedValue);

    ASPOSECPP_SHARED_API void SkipToEndElement(const SharedPtr<XmlSchemaInfo>& schemaInfo);

    ASPOSECPP_SHARED_API void EndValidation();

    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<XmlSchemaParticle>> GetExpectedParticles();

    ASPOSECPP_SHARED_API ArrayPtr<SharedPtr<XmlSchemaAttribute>> GetExpectedAttributes();


protected:


    static ArrayPtr<std::vector<bool>> ValidStates;


    SharedPtr<XmlSchemaSet> get_SchemaSet();

    XmlSchemaValidationFlags get_ValidationFlags();

    XmlSchemaContentType get_CurrentContentType();

    XmlSchemaContentProcessing get_CurrentProcessContents();

    bool get_ProcessIdentityConstraints();

    bool get_ReportValidationWarnings();

    bool get_ProcessSchemaHints();


    void GetUnspecifiedDefaultAttributes(const SharedPtr<Collections::Generic::List<SharedPtr<Object>>>& defaultAttributes, bool createNodeData);

    void SetDtdSchemaInfo(const SharedPtr<IDtdInfo>& dtdSchemaInfo);

    String GetConcatenatedValue();

    SharedPtr<Object> CheckMixedValueConstraint(const String& elementValue);

    void RecompileSchemaSet();

    String GetDefaultAttributePrefix(const String& attributeNS);

    static void ElementValidationError(const SharedPtr<XmlQualifiedName>& name, const SharedPtr<ValidationState>& context, System::Xml::Schema::ValidationEventHandler eventHandler, const SharedPtr<Object>& sender, const String& sourceUri, int32_t lineNo, int32_t linePos, const SharedPtr<XmlSchemaSet>& schemaSet);

    static void CompleteValidationError(const SharedPtr<ValidationState>& context, System::Xml::Schema::ValidationEventHandler eventHandler, const SharedPtr<Object>& sender, const String& sourceUri, int32_t lineNo, int32_t linePos, const SharedPtr<XmlSchemaSet>& schemaSet);

    static String PrintExpectedElements(const SharedPtr<Collections::Generic::List<SharedPtr<XmlSchemaParticle>>>& expected);

    static String PrintExpectedElements(const SharedPtr<Collections::Generic::List<String>>& expected);

    static String QNameString(const String& localName, const String& ns);

    static String BuildElementName(const SharedPtr<XmlQualifiedName>& qname);

    static String BuildElementName(const String& localName, const String& ns);

    static void SendValidationEvent(System::Xml::Schema::ValidationEventHandler eventHandler, const SharedPtr<Object>& sender, XmlSchemaValidationException e, XmlSeverityType severity);


    virtual ASPOSECPP_SHARED_API ~XmlSchemaValidator();


    #ifdef ASPOSE_GET_SHARED_MEMBERS

    ASPOSECPP_SHARED_API void GetSharedMembers(System::Object::shared_members_type& result) const override;

    #endif


    #ifdef __DBG_FOR_EACH_MEMBER

public:

    ASPOSECPP_SHARED_API void DBG_for_each_member(DBG::for_each_member_visitor& visitor) const override;

    const char* DBG_class_name() const override { return "XmlSchemaValidator"; }

#endif


private:


    SharedPtr<XmlSchemaSet> _schemaSet;

    XmlSchemaValidationFlags _validationFlags;

    int32_t _startIDConstraint;

    static const int32_t STACK_INCREMENT;

    bool _isRoot;

    bool _rootHasSchema;

    bool _attrValid;

    bool _checkEntity;

    SharedPtr<SchemaInfo> _compiledSchemaInfo;

    SharedPtr<IDtdInfo> _dtdSchemaInfo;

    SharedPtr<Collections::Generic::Dictionary<String, String>> _validatedNamespaces;

    SharedPtr<HWStack> _validationStack;

    SharedPtr<ValidationState> _context;

    ValidatorState _currentState;

    SharedPtr<Collections::Generic::Dictionary<SharedPtr<XmlQualifiedName>, SharedPtr<SchemaAttDef>>> _attPresence;

    SharedPtr<SchemaAttDef> _wildID;

    SharedPtr<Collections::Generic::Dictionary<String, String>> _IDs;

    SharedPtr<IdRefNode> _idRefListHead;

    SharedPtr<XmlQualifiedName> _contextQName;

    String _nsXs;

    String _nsXsi;

    String _nsXmlNs;

    String _nsXml;

    SharedPtr<XmlSchemaObject> _partialValidationType;

    SharedPtr<Text::StringBuilder> _textValue;

    WeakPtr<Object> _validationEventSender;

    SharedPtr<XmlNameTable> _nameTable;

    SharedPtr<IXmlLineInfo> _positionInfo;

    SharedPtr<IXmlLineInfo> _dummyPositionInfo;

    SharedPtr<System::Xml::XmlResolver> _xmlResolver;

    SharedPtr<Uri> _sourceUri;

    String _sourceUriString;

    WeakPtr<IXmlNamespaceResolver> _nsResolver;

    XmlSchemaContentProcessing _processContents;

    static SharedPtr<XmlSchemaAttribute> s_xsiTypeSO;

    static SharedPtr<XmlSchemaAttribute> s_xsiNilSO;

    static SharedPtr<XmlSchemaAttribute> s_xsiSLSO;

    static SharedPtr<XmlSchemaAttribute> s_xsiNoNsSLSO;

    String _xsiTypeString;

    String _xsiNilString;

    String _xsiSchemaLocationString;

    String _xsiNoNamespaceSchemaLocationString;

    static SharedPtr<XmlSchemaDatatype> s_dtQName;

    static SharedPtr<XmlSchemaDatatype> s_dtCDATA;

    static SharedPtr<XmlSchemaDatatype> s_dtStringArray;

    static const String Quote;

    static ArrayPtr<SharedPtr<XmlSchemaParticle>> s_emptyParticleArray;

    static ArrayPtr<SharedPtr<XmlSchemaAttribute>> s_emptyAttributeArray;

    XmlCharType _xmlCharType;

    static ArrayPtr<String> s_methodNames;


    bool get_StrictlyAssessed();

    bool get_HasSchema();

    bool get_HasIdentityConstraints();

    System::Xml::Schema::ValidationEventHandler get_EventHandler();


    void Init();

    void Reset();

    SharedPtr<Object> ValidateAttribute(String localName, String namespaceUri, XmlValueGetter attributeValueGetter, const String& attributeStringValue, const SharedPtr<XmlSchemaInfo>& schemaInfo);

    void ValidateText(const String& elementStringValue, XmlValueGetter elementValueGetter);

    void ValidateWhitespace(const String& elementStringValue, XmlValueGetter elementValueGetter);

    SharedPtr<Object> InternalValidateEndElement(const SharedPtr<XmlSchemaInfo>& schemaInfo, SharedPtr<Object> typedValue);

    void ProcessSchemaLocations(const String& xsiSchemaLocation, const String& xsiNoNamespaceSchemaLocation);

    SharedPtr<Object> ValidateElementContext(const SharedPtr<XmlQualifiedName>& elementName, bool& invalidElementInContext);

    SharedPtr<XmlSchemaElement> GetSubstitutionGroupHead(const SharedPtr<XmlQualifiedName>& member);

    SharedPtr<Object> ValidateAtomicValue(const String& stringValue, SharedPtr<XmlSchemaSimpleType>& memberType);

    SharedPtr<Object> ValidateAtomicValue(const SharedPtr<Object>& parsedValue, SharedPtr<XmlSchemaSimpleType>& memberType);

    String GetTypeName(const SharedPtr<SchemaDeclBase>& decl);

    void SaveTextValue(const SharedPtr<Object>& value);

    void Push(const SharedPtr<XmlQualifiedName>& elementName);

    void Pop();

    void AddXsiAttributes(const SharedPtr<Collections::Generic::List<SharedPtr<XmlSchemaAttribute>>>& attList);

    SharedPtr<SchemaElementDecl> FastGetElementDecl(const SharedPtr<XmlQualifiedName>& elementName, const SharedPtr<Object>& particle);

    SharedPtr<SchemaElementDecl> CheckXsiTypeAndNil(SharedPtr<SchemaElementDecl> elementDecl, const String& xsiType, const String& xsiNil, bool& declFound);

    void ThrowDeclNotFoundWarningOrError(bool declFound);

    void CheckElementProperties();

    void ValidateStartElementIdentityConstraints();

    SharedPtr<SchemaAttDef> CheckIsXmlAttribute(const SharedPtr<XmlQualifiedName>& attQName);

    void AddXmlNamespaceSchema();

    void LoadSchema(const String& uri, const String& url);

    void ProcessTokenizedType(XmlTokenizedType ttype, const String& name, bool attrValue);

    SharedPtr<Object> CheckAttributeValue(const SharedPtr<Object>& value, const SharedPtr<SchemaAttDef>& attdef);

    SharedPtr<Object> CheckElementValue(const String& stringValue);

    void CheckTokenizedTypes(const SharedPtr<XmlSchemaDatatype>& dtype, const SharedPtr<Object>& typedValue, bool attrValue);

    SharedPtr<Object> FindId(const String& name);

    void CheckForwardRefs();

    void CheckStateTransition(ValidatorState toState, const String& methodName);

    void ClearPSVI();

    void CheckRequiredAttributes(const SharedPtr<SchemaElementDecl>& currentElementDecl);

    SharedPtr<XmlSchemaElement> GetSchemaElement();

    void AddIdentityConstraints();

    void ElementIdentityConstraints();

    void AttributeIdentityConstraints(const String& name, const String& ns, const SharedPtr<Object>& obj, const String& sobj, const SharedPtr<XmlSchemaDatatype>& datatype);

    void EndElementIdentityConstraints(const SharedPtr<Object>& typedValue, const String& stringValue, const SharedPtr<XmlSchemaDatatype>& datatype);

    static void BuildXsiAttributes();

    static void PrintNamesWithNS(const SharedPtr<Collections::Generic::List<SharedPtr<XmlQualifiedName>>>& expected, const SharedPtr<Text::StringBuilder>& builder);

    static void EnumerateAny(const SharedPtr<Text::StringBuilder>& builder, const String& namespaces);

    void ProcessEntity(const String& name);

    void SendValidationEvent(const String& code);

    void SendValidationEvent(const String& code, const ArrayPtr<String>& args);

    void SendValidationEvent(const String& code, const String& arg);

    void SendValidationEvent(const String& code, const String& arg1, const String& arg2);

    void SendValidationEvent(const String& code, const ArrayPtr<String>& args, Exception innerException, XmlSeverityType severity);

    void SendValidationEvent(const String& code, const ArrayPtr<String>& args, Exception innerException);

    void SendValidationEvent(XmlSchemaValidationException e);

    void SendValidationEvent(XmlSchemaException e);

    void SendValidationEvent(const String& code, const String& msg, XmlSeverityType severity);

    void SendValidationEvent(XmlSchemaValidationException e, XmlSeverityType severity);


    static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;


};


} // namespace Schema

} // namespace Xml

} // namespace System


System::Collections::Generic::List
List forward declaration.
Definition: list.h:127

System::ExceptionWrapper< Details_XmlSchemaException >

System::Object
Base class that enables using methods available for System.Object class in C#. All non-trivial classe...
Definition: object.h:62

System::SmartPtr
Pointer class to wrap types being allocated on heap. Use it to manage memory for classes inheriting O...
Definition: smart_ptr.h:180

System::String
String class used across the library. Is a substitute for C# System.String when translating code....
Definition: string.h:122

System::WeakPtr
Subclass of System::SmartPtr which sets itself to weak mode at construction. Please note that this cl...
Definition: weak_ptr.h:18

System::Xml::Schema::XmlSchemaValidator
Represents an XML Schema Definition Language (XSD) Schema validation engine. The XmlSchemaValidator c...
Definition: xml_schema_validator.h:93

System::Xml::Schema::XmlSchemaValidator::ValidateText
void ValidateText(const String &elementValue)
Validates whether the text string specified is allowed in the current element context,...

System::Xml::Schema::XmlSchemaValidator::get_LineInfoProvider
SharedPtr< IXmlLineInfo > get_LineInfoProvider()
Returns the line number information for the XML node being validated.

System::Xml::Schema::XmlSchemaValidator::ValidateAttribute
SharedPtr< Object > ValidateAttribute(const String &localName, const String &namespaceUri, const String &attributeValue, const SharedPtr< XmlSchemaInfo > &schemaInfo)
Validates the attribute name, namespace URI, and value in the current element context.

System::Xml::Schema::XmlSchemaValidator::get_ValidationEventSender
SharedPtr< Object > get_ValidationEventSender()
Returns the object sent as the sender object of a validation event.

System::Xml::Schema::XmlSchemaValidator::~XmlSchemaValidator
virtual ~XmlSchemaValidator()

System::Xml::Schema::XmlSchemaValidator::XmlSchemaValidator
XmlSchemaValidator(const SharedPtr< XmlNameTable > &nameTable, const SharedPtr< XmlSchemaSet > &schemas, const SharedPtr< IXmlNamespaceResolver > &namespaceResolver, XmlSchemaValidationFlags validationFlags)
Initializes a new instance of the XmlSchemaValidator class.

System::Xml::Schema::XmlSchemaValidator::set_SourceUri
void set_SourceUri(const SharedPtr< Uri > &value)
Sets the source URI for the XML node being validated.

System::Xml::Schema::XmlSchemaValidator::ValidateEndElement
SharedPtr< Object > ValidateEndElement(const SharedPtr< XmlSchemaInfo > &schemaInfo)
Verifies if the text content of the element is valid according to its data type for elements with sim...

System::Xml::Schema::XmlSchemaValidator::ValidateWhitespace
void ValidateWhitespace(const String &elementValue)
Validates whether the white space in the string specified is allowed in the current element context,...

System::Xml::Schema::XmlSchemaValidator::ValidateElement
void ValidateElement(const String &localName, const String &namespaceUri, const SharedPtr< XmlSchemaInfo > &schemaInfo, const String &xsiType, const String &xsiNil, const String &xsiSchemaLocation, const String &xsiNoNamespaceSchemaLocation)
Validates the element in the current context with the xsi:Type, xsi:Nil, xsi:SchemaLocation,...

System::Xml::Schema::XmlSchemaValidator::AddSchema
void AddSchema(const SharedPtr< XmlSchema > &schema)
Adds an XML Schema Definition Language (XSD) schema to the set of schemas used for validation.

System::Xml::Schema::XmlSchemaValidator::ValidateText
void ValidateText(XmlValueGetter elementValue)
Validates whether the text returned by the XmlValueGetter object specified is allowed in the current ...

System::Xml::Schema::XmlSchemaValidator::EndValidation
void EndValidation()
Ends validation and checks identity constraints for the entire XML document.

System::Xml::Schema::XmlSchemaValidator::ValidateElement
void ValidateElement(const String &localName, const String &namespaceUri, const SharedPtr< XmlSchemaInfo > &schemaInfo)
Validates the element in the current context.

System::Xml::Schema::XmlSchemaValidator::set_LineInfoProvider
void set_LineInfoProvider(const SharedPtr< IXmlLineInfo > &value)
Sets the line number information for the XML node being validated.

System::Xml::Schema::XmlSchemaValidator::get_SourceUri
SharedPtr< Uri > get_SourceUri()
Returns the source URI for the XML node being validated.

System::Xml::Schema::XmlSchemaValidator::set_XmlResolver
void set_XmlResolver(const SharedPtr< System::Xml::XmlResolver > &value)
Sets the XmlResolver object used to resolve xs:import and xs:include elements as well as xsi:schemaLo...

System::Xml::Schema::XmlSchemaValidator::ValidateEndOfAttributes
void ValidateEndOfAttributes(const SharedPtr< XmlSchemaInfo > &schemaInfo)
Verifies whether all the required attributes in the element context are present and prepares the XmlS...

System::Xml::Schema::XmlSchemaValidator::GetUnspecifiedDefaultAttributes
void GetUnspecifiedDefaultAttributes(const SharedPtr< Collections::Generic::List< SharedPtr< Object > > > &defaultAttributes)
Validates identity constraints on the default attributes and populates the List specified with XmlSch...

System::Xml::Schema::XmlSchemaValidator::Initialize
void Initialize()
Initializes the state of the XmlSchemaValidator object.

System::Xml::Schema::XmlSchemaValidator::set_ValidationEventSender
void set_ValidationEventSender(const SharedPtr< Object > &value)
Sets the object sent as the sender object of a validation event.

System::Xml::Schema::XmlSchemaValidator::ValidationEventHandler
System::Xml::Schema::ValidationEventHandler ValidationEventHandler
The ValidationEventHandler that receives schema validation warnings and errors encountered during sch...
Definition: xml_schema_validator.h:118

System::Xml::Schema::XmlSchemaValidator::GetExpectedAttributes
ArrayPtr< SharedPtr< XmlSchemaAttribute > > GetExpectedAttributes()
Returns the expected attributes for the current element context.

System::Xml::Schema::XmlSchemaValidator::SkipToEndElement
void SkipToEndElement(const SharedPtr< XmlSchemaInfo > &schemaInfo)
Skips validation of the current element content and prepares the XmlSchemaValidator object to validat...

System::Xml::Schema::XmlSchemaValidator::ValidateAttribute
SharedPtr< Object > ValidateAttribute(const String &localName, const String &namespaceUri, XmlValueGetter attributeValue, const SharedPtr< XmlSchemaInfo > &schemaInfo)
Validates the attribute name, namespace URI, and value in the current element context.

System::Xml::Schema::XmlSchemaValidator::Initialize
void Initialize(const SharedPtr< XmlSchemaObject > &partialValidationType)
Initializes the state of the XmlSchemaValidator object using the XmlSchemaObject specified for partia...

System::Xml::Schema::XmlSchemaValidator::ValidateWhitespace
void ValidateWhitespace(XmlValueGetter elementValue)
Validates whether the white space returned by the XmlValueGetter object specified is allowed in the c...

System::Xml::Schema::XmlSchemaValidator::GetExpectedParticles
ArrayPtr< SharedPtr< XmlSchemaParticle > > GetExpectedParticles()
Returns the expected particles in the current element context.

System::Xml::Schema::XmlSchemaValidator::ValidateEndElement
SharedPtr< Object > ValidateEndElement(const SharedPtr< XmlSchemaInfo > &schemaInfo, const SharedPtr< Object > &typedValue)
Verifies if the text content of the element specified is valid according to its data type.

System::Xml::XmlCharType
For internal purposes. Do not use this class directly.
Definition: xml_char_type.h:61

System::Collections::Generic::List
class ASPOSECPP_SHARED_CLASS List
Definition: ienumerable.h:18

System::Drawing::Imaging::ColorAdjustType::Text
@ Text
Defines color adjustment information for text.

System::Xml::Schema::XmlSchemaValidationException
System::ExceptionWrapper< Details_XmlSchemaValidationException > XmlSchemaValidationException
Definition: xml_schema_validation_exception.h:36

System::Xml::Schema::XmlSchemaException
System::ExceptionWrapper< Details_XmlSchemaException > XmlSchemaException
Definition: xml_schema_exception.h:76

System::Xml::Schema::XmlSchemaContentType
XmlSchemaContentType
Enumerations for the content model of the complex type. This represents the content in the post-schem...
Definition: xml_schema_content_type.h:18

System::Xml::Schema::ValidationEventHandler
System::MulticastDelegate< void(SharedPtr< Object >, SharedPtr< ValidationEventArgs >)> ValidationEventHandler
Represents the callback method that will handle XML schema validation events and the ValidationEventA...
Definition: validation_event_handler.h:33

System::Xml::Schema::XmlValueGetter
System::MulticastDelegate< SharedPtr< Object >()> XmlValueGetter
A callback used by the XmlSchemaValidator class to pass attribute, text,and white space values as a r...
Definition: xml_schema_validator.h:85

System::Xml::Schema::XmlSeverityType
XmlSeverityType
Represents the severity of the validation event.
Definition: xml_severity_type.h:17

System::Xml::Schema::XmlSchemaContentProcessing
XmlSchemaContentProcessing
Provides information about the validation mode of any and anyAttribute element replacements.
Definition: xml_schema_content_processing.h:17

System::Xml::Schema::XmlSchemaValidationFlags
XmlSchemaValidationFlags
Specifies schema validation options used by the XmlSchemaValidator and XmlReader classes.
Definition: xml_schema_validation_flags.h:18

System::Xml::ValidationType::Schema
@ Schema
Validate according to XML Schema definition language (XSD) schemas, including inline XML Schemas....

System::Xml::XmlOutputMethod::Xml
@ Xml
Serialize according to the XML 1.0 rules.

System::Xml::XmlTokenizedType
XmlTokenizedType
Represents the XML type for the string. This allows the string to be read as a particular XML type,...
Definition: xml_tokenized_type.h:16

System
Definition: db_command.h:9