diff --git a/GeneratedSchemaLibraries/ParaParserXml/ParaParserXml.csproj b/GeneratedSchemaLibraries/ParaParserXml/ParaParserXml.csproj new file mode 100644 index 00000000..71f8a83e --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/ParaParserXml.csproj @@ -0,0 +1,22 @@ + + + + netstandard2.0 + + + + + + + + + + + + + + + TargetFramework=netstandard2.0 + + + \ No newline at end of file diff --git a/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd new file mode 100644 index 00000000..2aaa0e89 --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd @@ -0,0 +1,208 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.config b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.config new file mode 100644 index 00000000..9d1ebeff --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.config @@ -0,0 +1,13 @@ + + + + + + false + + false + + + + + \ No newline at end of file diff --git a/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.cs b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.cs new file mode 100644 index 00000000..4be7e244 --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/paraparse.xsd.cs @@ -0,0 +1,8772 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ParaParse.Xml { + using System; + using System.Collections; + using System.Collections.Generic; + using System.ComponentModel; + using System.IO; + using System.Linq; + using System.Diagnostics; + using System.Xml; + using System.Xml.Schema; + using System.Xml.Linq; + using global::Xml.Schema.Linq; + + + /// + /// + /// Regular expression: ((NamedRule1 | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public partial class NamedRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static NamedRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static NamedRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static NamedRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator NamedRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule1 | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public NamedRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRule1XName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RuleNameXName = System.Xml.Linq.XName.Get("RuleName", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string RuleName { + get { + XAttribute x = this.Attribute(RuleNameXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(RuleNameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + static NamedRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRule1XName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRule1XName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class RecursiveRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static RecursiveRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static RecursiveRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static RecursiveRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator RecursiveRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public RecursiveRule() { + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class StringRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static StringRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static StringRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static StringRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator StringRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public StringRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName PatternXName = System.Xml.Linq.XName.Get("Pattern", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string Pattern { + get { + XAttribute x = this.Attribute(PatternXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(PatternXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class CaseInvariantStringRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static CaseInvariantStringRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static CaseInvariantStringRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static CaseInvariantStringRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator CaseInvariantStringRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public CaseInvariantStringRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName PatternXName = System.Xml.Linq.XName.Get("Pattern", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string Pattern { + get { + XAttribute x = this.Attribute(PatternXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(PatternXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class AnyCharRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static AnyCharRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static AnyCharRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static AnyCharRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator AnyCharRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public AnyCharRule() { + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class CharRangeRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static CharRangeRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static CharRangeRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static CharRangeRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator CharRangeRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public CharRangeRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName FromXName = System.Xml.Linq.XName.Get("From", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string From { + get { + XAttribute x = this.Attribute(FromXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(FromXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ToXName = System.Xml.Linq.XName.Get("To", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string To { + get { + XAttribute x = this.Attribute(ToXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(ToXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class CharSetRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static CharSetRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static CharSetRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static CharSetRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator CharSetRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public CharSetRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharsXName = System.Xml.Linq.XName.Get("Chars", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string Chars { + get { + XAttribute x = this.Attribute(CharsXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(CharsXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class CharRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static CharRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static CharRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static CharRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator CharRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public CharRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharXName = System.Xml.Linq.XName.Get("Char", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string Char { + get { + XAttribute x = this.Attribute(CharXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(CharXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class EndOfInputRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static EndOfInputRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static EndOfInputRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static EndOfInputRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator EndOfInputRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public EndOfInputRule() { + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule1 | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public partial class NodeRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static NodeRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static NodeRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static NodeRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator NodeRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule1 | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public NodeRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRule1XName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeNameXName = System.Xml.Linq.XName.Get("NodeName", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string NodeName { + get { + XAttribute x = this.Attribute(NodeNameXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(NodeNameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + static NodeRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRule1XName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRule1XName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule1 | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public partial class CountedRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static CountedRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static CountedRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static CountedRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator CountedRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule1 | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public CountedRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRule1XName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName MinXName = System.Xml.Linq.XName.Get("Min", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual int Min { + get { + XAttribute x = this.Attribute(MinXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype); + } + set { + this.SetAttribute(MinXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName MaxXName = System.Xml.Linq.XName.Get("Max", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual int Max { + get { + XAttribute x = this.Attribute(MaxXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype); + } + set { + this.SetAttribute(MaxXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Int).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + static CountedRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRule1XName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRule1XName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public partial class OnFail : global::ParaParse.Xml.Rule, IXMetaData { + + public new static OnFail Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static OnFail Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static OnFail Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator OnFail(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public OnFail() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + XElement x = this.GetElement(NamedRuleXName); + if ((x == null)) { + return null; + } + return ((NamedRule)(x)); + } + set { + this.SetElement(NamedRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + XElement x = this.GetElement(RecursiveRuleXName); + if ((x == null)) { + return null; + } + return ((RecursiveRule)(x)); + } + set { + this.SetElement(RecursiveRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + XElement x = this.GetElement(StringRuleXName); + if ((x == null)) { + return null; + } + return ((StringRule)(x)); + } + set { + this.SetElement(StringRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + XElement x = this.GetElement(CaseInvariantStringRuleXName); + if ((x == null)) { + return null; + } + return ((CaseInvariantStringRule)(x)); + } + set { + this.SetElement(CaseInvariantStringRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + XElement x = this.GetElement(AnyCharRuleXName); + if ((x == null)) { + return null; + } + return ((AnyCharRule)(x)); + } + set { + this.SetElement(AnyCharRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + XElement x = this.GetElement(CharRangeRuleXName); + if ((x == null)) { + return null; + } + return ((CharRangeRule)(x)); + } + set { + this.SetElement(CharRangeRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + XElement x = this.GetElement(CharSetRuleXName); + if ((x == null)) { + return null; + } + return ((CharSetRule)(x)); + } + set { + this.SetElement(CharSetRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + XElement x = this.GetElement(CharRuleXName); + if ((x == null)) { + return null; + } + return ((CharRule)(x)); + } + set { + this.SetElement(CharRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + XElement x = this.GetElement(EndOfInputRuleXName); + if ((x == null)) { + return null; + } + return ((EndOfInputRule)(x)); + } + set { + this.SetElement(EndOfInputRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + XElement x = this.GetElement(NodeRuleXName); + if ((x == null)) { + return null; + } + return ((NodeRule)(x)); + } + set { + this.SetElement(NodeRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + XElement x = this.GetElement(ZeroOrMoreRuleXName); + if ((x == null)) { + return null; + } + return ((ZeroOrMoreRule)(x)); + } + set { + this.SetElement(ZeroOrMoreRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + XElement x = this.GetElement(OneOrMoreRuleXName); + if ((x == null)) { + return null; + } + return ((OneOrMoreRule)(x)); + } + set { + this.SetElement(OneOrMoreRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + XElement x = this.GetElement(CountedRuleXName); + if ((x == null)) { + return null; + } + return ((CountedRule)(x)); + } + set { + this.SetElement(CountedRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + XElement x = this.GetElement(OptionalRuleXName); + if ((x == null)) { + return null; + } + return ((OptionalRule)(x)); + } + set { + this.SetElement(OptionalRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + XElement x = this.GetElement(SequenceRuleXName); + if ((x == null)) { + return null; + } + return ((SequenceRule)(x)); + } + set { + this.SetElement(SequenceRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + XElement x = this.GetElement(ChoiceRuleXName); + if ((x == null)) { + return null; + } + return ((ChoiceRule)(x)); + } + set { + this.SetElement(ChoiceRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + XElement x = this.GetElement(AtRuleXName); + if ((x == null)) { + return null; + } + return ((AtRule)(x)); + } + set { + this.SetElement(AtRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + XElement x = this.GetElement(NotAtRuleXName); + if ((x == null)) { + return null; + } + return ((NotAtRule)(x)); + } + set { + this.SetElement(NotAtRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFail1XName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual OnFail OnFail1 { + get { + XElement x = this.GetElement(OnFail1XName); + if ((x == null)) { + return null; + } + return ((OnFail)(x)); + } + set { + this.SetElement(OnFail1XName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail1 | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + XElement x = this.GetElement(BooleanRuleXName); + if ((x == null)) { + return null; + } + return ((BooleanRule)(x)); + } + set { + this.SetElement(BooleanRuleXName, value); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + static OnFail() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFail1XName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFail1XName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class BooleanRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static BooleanRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static BooleanRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static BooleanRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator BooleanRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + public BooleanRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ValueXName = System.Xml.Linq.XName.Get("Value", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual bool Value { + get { + XAttribute x = this.Attribute(ValueXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype); + } + set { + this.SetAttribute(ValueXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.Boolean).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public partial class grammar : XTypedElement, IXMetaData { + + public void Save(string xmlFile) { + XTypedServices.Save(xmlFile, Untyped); + } + + public void Save(System.IO.TextWriter tw) { + XTypedServices.Save(tw, Untyped); + } + + public void Save(System.Xml.XmlWriter xmlWriter) { + XTypedServices.Save(xmlWriter, Untyped); + } + + public static grammar Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static grammar Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static grammar Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator grammar(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public grammar() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NamedRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList NamedRule { + get { + if ((this.NamedRuleField == null)) { + this.NamedRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NamedRuleXName); + } + return this.NamedRuleField; + } + set { + if ((value == null)) { + this.NamedRuleField = null; + } + else { + if ((this.NamedRuleField == null)) { + this.NamedRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NamedRuleXName); + } + else { + XTypedServices.SetList(this.NamedRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList RecursiveRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList RecursiveRule { + get { + if ((this.RecursiveRuleField == null)) { + this.RecursiveRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, RecursiveRuleXName); + } + return this.RecursiveRuleField; + } + set { + if ((value == null)) { + this.RecursiveRuleField = null; + } + else { + if ((this.RecursiveRuleField == null)) { + this.RecursiveRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, RecursiveRuleXName); + } + else { + XTypedServices.SetList(this.RecursiveRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList StringRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList StringRule { + get { + if ((this.StringRuleField == null)) { + this.StringRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, StringRuleXName); + } + return this.StringRuleField; + } + set { + if ((value == null)) { + this.StringRuleField = null; + } + else { + if ((this.StringRuleField == null)) { + this.StringRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, StringRuleXName); + } + else { + XTypedServices.SetList(this.StringRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CaseInvariantStringRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList CaseInvariantStringRule { + get { + if ((this.CaseInvariantStringRuleField == null)) { + this.CaseInvariantStringRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CaseInvariantStringRuleXName); + } + return this.CaseInvariantStringRuleField; + } + set { + if ((value == null)) { + this.CaseInvariantStringRuleField = null; + } + else { + if ((this.CaseInvariantStringRuleField == null)) { + this.CaseInvariantStringRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CaseInvariantStringRuleXName); + } + else { + XTypedServices.SetList(this.CaseInvariantStringRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList AnyCharRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList AnyCharRule { + get { + if ((this.AnyCharRuleField == null)) { + this.AnyCharRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, AnyCharRuleXName); + } + return this.AnyCharRuleField; + } + set { + if ((value == null)) { + this.AnyCharRuleField = null; + } + else { + if ((this.AnyCharRuleField == null)) { + this.AnyCharRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, AnyCharRuleXName); + } + else { + XTypedServices.SetList(this.AnyCharRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharRangeRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList CharRangeRule { + get { + if ((this.CharRangeRuleField == null)) { + this.CharRangeRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharRangeRuleXName); + } + return this.CharRangeRuleField; + } + set { + if ((value == null)) { + this.CharRangeRuleField = null; + } + else { + if ((this.CharRangeRuleField == null)) { + this.CharRangeRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharRangeRuleXName); + } + else { + XTypedServices.SetList(this.CharRangeRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharSetRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList CharSetRule { + get { + if ((this.CharSetRuleField == null)) { + this.CharSetRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharSetRuleXName); + } + return this.CharSetRuleField; + } + set { + if ((value == null)) { + this.CharSetRuleField = null; + } + else { + if ((this.CharSetRuleField == null)) { + this.CharSetRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharSetRuleXName); + } + else { + XTypedServices.SetList(this.CharSetRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList CharRule { + get { + if ((this.CharRuleField == null)) { + this.CharRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharRuleXName); + } + return this.CharRuleField; + } + set { + if ((value == null)) { + this.CharRuleField = null; + } + else { + if ((this.CharRuleField == null)) { + this.CharRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharRuleXName); + } + else { + XTypedServices.SetList(this.CharRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList EndOfInputRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList EndOfInputRule { + get { + if ((this.EndOfInputRuleField == null)) { + this.EndOfInputRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, EndOfInputRuleXName); + } + return this.EndOfInputRuleField; + } + set { + if ((value == null)) { + this.EndOfInputRuleField = null; + } + else { + if ((this.EndOfInputRuleField == null)) { + this.EndOfInputRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, EndOfInputRuleXName); + } + else { + XTypedServices.SetList(this.EndOfInputRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NodeRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList NodeRule { + get { + if ((this.NodeRuleField == null)) { + this.NodeRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NodeRuleXName); + } + return this.NodeRuleField; + } + set { + if ((value == null)) { + this.NodeRuleField = null; + } + else { + if ((this.NodeRuleField == null)) { + this.NodeRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NodeRuleXName); + } + else { + XTypedServices.SetList(this.NodeRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList ZeroOrMoreRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList ZeroOrMoreRule { + get { + if ((this.ZeroOrMoreRuleField == null)) { + this.ZeroOrMoreRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, ZeroOrMoreRuleXName); + } + return this.ZeroOrMoreRuleField; + } + set { + if ((value == null)) { + this.ZeroOrMoreRuleField = null; + } + else { + if ((this.ZeroOrMoreRuleField == null)) { + this.ZeroOrMoreRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, ZeroOrMoreRuleXName); + } + else { + XTypedServices.SetList(this.ZeroOrMoreRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OneOrMoreRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList OneOrMoreRule { + get { + if ((this.OneOrMoreRuleField == null)) { + this.OneOrMoreRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, OneOrMoreRuleXName); + } + return this.OneOrMoreRuleField; + } + set { + if ((value == null)) { + this.OneOrMoreRuleField = null; + } + else { + if ((this.OneOrMoreRuleField == null)) { + this.OneOrMoreRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OneOrMoreRuleXName); + } + else { + XTypedServices.SetList(this.OneOrMoreRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CountedRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList CountedRule { + get { + if ((this.CountedRuleField == null)) { + this.CountedRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CountedRuleXName); + } + return this.CountedRuleField; + } + set { + if ((value == null)) { + this.CountedRuleField = null; + } + else { + if ((this.CountedRuleField == null)) { + this.CountedRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CountedRuleXName); + } + else { + XTypedServices.SetList(this.CountedRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OptionalRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList OptionalRule { + get { + if ((this.OptionalRuleField == null)) { + this.OptionalRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, OptionalRuleXName); + } + return this.OptionalRuleField; + } + set { + if ((value == null)) { + this.OptionalRuleField = null; + } + else { + if ((this.OptionalRuleField == null)) { + this.OptionalRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OptionalRuleXName); + } + else { + XTypedServices.SetList(this.OptionalRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList SequenceRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList SequenceRule { + get { + if ((this.SequenceRuleField == null)) { + this.SequenceRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, SequenceRuleXName); + } + return this.SequenceRuleField; + } + set { + if ((value == null)) { + this.SequenceRuleField = null; + } + else { + if ((this.SequenceRuleField == null)) { + this.SequenceRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, SequenceRuleXName); + } + else { + XTypedServices.SetList(this.SequenceRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList ChoiceRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList ChoiceRule { + get { + if ((this.ChoiceRuleField == null)) { + this.ChoiceRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, ChoiceRuleXName); + } + return this.ChoiceRuleField; + } + set { + if ((value == null)) { + this.ChoiceRuleField = null; + } + else { + if ((this.ChoiceRuleField == null)) { + this.ChoiceRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, ChoiceRuleXName); + } + else { + XTypedServices.SetList(this.ChoiceRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList AtRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList AtRule { + get { + if ((this.AtRuleField == null)) { + this.AtRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, AtRuleXName); + } + return this.AtRuleField; + } + set { + if ((value == null)) { + this.AtRuleField = null; + } + else { + if ((this.AtRuleField == null)) { + this.AtRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, AtRuleXName); + } + else { + XTypedServices.SetList(this.AtRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NotAtRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList NotAtRule { + get { + if ((this.NotAtRuleField == null)) { + this.NotAtRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NotAtRuleXName); + } + return this.NotAtRuleField; + } + set { + if ((value == null)) { + this.NotAtRuleField = null; + } + else { + if ((this.NotAtRuleField == null)) { + this.NotAtRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NotAtRuleXName); + } + else { + XTypedServices.SetList(this.NotAtRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OnFailField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList OnFail { + get { + if ((this.OnFailField == null)) { + this.OnFailField = new XTypedList(this, LinqToXsdTypeManager.Instance, OnFailXName); + } + return this.OnFailField; + } + set { + if ((value == null)) { + this.OnFailField = null; + } + else { + if ((this.OnFailField == null)) { + this.OnFailField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OnFailXName); + } + else { + XTypedServices.SetList(this.OnFailField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList BooleanRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))+ + /// + /// + public virtual IList BooleanRule { + get { + if ((this.BooleanRuleField == null)) { + this.BooleanRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, BooleanRuleXName); + } + return this.BooleanRuleField; + } + set { + if ((value == null)) { + this.BooleanRuleField = null; + } + else { + if ((this.BooleanRuleField == null)) { + this.BooleanRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, BooleanRuleXName); + } + else { + XTypedServices.SetList(this.BooleanRuleField, value); + } + } + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("grammar", "urn:ParaParse.XML"); + + static grammar() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public abstract partial class RuleType : XTypedElement, IXMetaData { + + public static explicit operator RuleType(XElement xe) { return (RuleType)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public RuleType() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NameXName = System.Xml.Linq.XName.Get("Name", ""); + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + XAttribute x = this.Attribute(NameXName); + if ((x == null)) { + return null; + } + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(NameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"); + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Fragment; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public partial class SingleChildRule : global::ParaParse.Xml.RuleType, IXMetaData { + + public static explicit operator SingleChildRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public SingleChildRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + XElement x = this.GetElement(NamedRuleXName); + if ((x == null)) { + return null; + } + return ((NamedRule)(x)); + } + set { + this.SetElement(NamedRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + XElement x = this.GetElement(RecursiveRuleXName); + if ((x == null)) { + return null; + } + return ((RecursiveRule)(x)); + } + set { + this.SetElement(RecursiveRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + XElement x = this.GetElement(StringRuleXName); + if ((x == null)) { + return null; + } + return ((StringRule)(x)); + } + set { + this.SetElement(StringRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + XElement x = this.GetElement(CaseInvariantStringRuleXName); + if ((x == null)) { + return null; + } + return ((CaseInvariantStringRule)(x)); + } + set { + this.SetElement(CaseInvariantStringRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + XElement x = this.GetElement(AnyCharRuleXName); + if ((x == null)) { + return null; + } + return ((AnyCharRule)(x)); + } + set { + this.SetElement(AnyCharRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + XElement x = this.GetElement(CharRangeRuleXName); + if ((x == null)) { + return null; + } + return ((CharRangeRule)(x)); + } + set { + this.SetElement(CharRangeRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + XElement x = this.GetElement(CharSetRuleXName); + if ((x == null)) { + return null; + } + return ((CharSetRule)(x)); + } + set { + this.SetElement(CharSetRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + XElement x = this.GetElement(CharRuleXName); + if ((x == null)) { + return null; + } + return ((CharRule)(x)); + } + set { + this.SetElement(CharRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + XElement x = this.GetElement(EndOfInputRuleXName); + if ((x == null)) { + return null; + } + return ((EndOfInputRule)(x)); + } + set { + this.SetElement(EndOfInputRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + XElement x = this.GetElement(NodeRuleXName); + if ((x == null)) { + return null; + } + return ((NodeRule)(x)); + } + set { + this.SetElement(NodeRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + XElement x = this.GetElement(ZeroOrMoreRuleXName); + if ((x == null)) { + return null; + } + return ((ZeroOrMoreRule)(x)); + } + set { + this.SetElement(ZeroOrMoreRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + XElement x = this.GetElement(OneOrMoreRuleXName); + if ((x == null)) { + return null; + } + return ((OneOrMoreRule)(x)); + } + set { + this.SetElement(OneOrMoreRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + XElement x = this.GetElement(CountedRuleXName); + if ((x == null)) { + return null; + } + return ((CountedRule)(x)); + } + set { + this.SetElement(CountedRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + XElement x = this.GetElement(OptionalRuleXName); + if ((x == null)) { + return null; + } + return ((OptionalRule)(x)); + } + set { + this.SetElement(OptionalRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + XElement x = this.GetElement(SequenceRuleXName); + if ((x == null)) { + return null; + } + return ((SequenceRule)(x)); + } + set { + this.SetElement(SequenceRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + XElement x = this.GetElement(ChoiceRuleXName); + if ((x == null)) { + return null; + } + return ((ChoiceRule)(x)); + } + set { + this.SetElement(ChoiceRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + XElement x = this.GetElement(AtRuleXName); + if ((x == null)) { + return null; + } + return ((AtRule)(x)); + } + set { + this.SetElement(AtRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + XElement x = this.GetElement(NotAtRuleXName); + if ((x == null)) { + return null; + } + return ((NotAtRule)(x)); + } + set { + this.SetElement(NotAtRuleXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + XElement x = this.GetElement(OnFailXName); + if ((x == null)) { + return null; + } + return ((OnFail)(x)); + } + set { + this.SetElement(OnFailXName, value); + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + XElement x = this.GetElement(BooleanRuleXName); + if ((x == null)) { + return null; + } + return ((BooleanRule)(x)); + } + set { + this.SetElement(BooleanRuleXName, value); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SingleChildRule", "urn:ParaParse.XML"); + + static SingleChildRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Fragment; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public partial class MultiChildRule : global::ParaParse.Xml.RuleType, IXMetaData { + + public static explicit operator MultiChildRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public MultiChildRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NamedRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NamedRule { + get { + if ((this.NamedRuleField == null)) { + this.NamedRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NamedRuleXName); + } + return this.NamedRuleField; + } + set { + if ((value == null)) { + this.NamedRuleField = null; + } + else { + if ((this.NamedRuleField == null)) { + this.NamedRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NamedRuleXName); + } + else { + XTypedServices.SetList(this.NamedRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RecursiveRuleXName = System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList RecursiveRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList RecursiveRule { + get { + if ((this.RecursiveRuleField == null)) { + this.RecursiveRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, RecursiveRuleXName); + } + return this.RecursiveRuleField; + } + set { + if ((value == null)) { + this.RecursiveRuleField = null; + } + else { + if ((this.RecursiveRuleField == null)) { + this.RecursiveRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, RecursiveRuleXName); + } + else { + XTypedServices.SetList(this.RecursiveRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName StringRuleXName = System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList StringRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList StringRule { + get { + if ((this.StringRuleField == null)) { + this.StringRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, StringRuleXName); + } + return this.StringRuleField; + } + set { + if ((value == null)) { + this.StringRuleField = null; + } + else { + if ((this.StringRuleField == null)) { + this.StringRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, StringRuleXName); + } + else { + XTypedServices.SetList(this.StringRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CaseInvariantStringRuleXName = System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CaseInvariantStringRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CaseInvariantStringRule { + get { + if ((this.CaseInvariantStringRuleField == null)) { + this.CaseInvariantStringRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CaseInvariantStringRuleXName); + } + return this.CaseInvariantStringRuleField; + } + set { + if ((value == null)) { + this.CaseInvariantStringRuleField = null; + } + else { + if ((this.CaseInvariantStringRuleField == null)) { + this.CaseInvariantStringRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CaseInvariantStringRuleXName); + } + else { + XTypedServices.SetList(this.CaseInvariantStringRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AnyCharRuleXName = System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList AnyCharRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AnyCharRule { + get { + if ((this.AnyCharRuleField == null)) { + this.AnyCharRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, AnyCharRuleXName); + } + return this.AnyCharRuleField; + } + set { + if ((value == null)) { + this.AnyCharRuleField = null; + } + else { + if ((this.AnyCharRuleField == null)) { + this.AnyCharRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, AnyCharRuleXName); + } + else { + XTypedServices.SetList(this.AnyCharRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRangeRuleXName = System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharRangeRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRangeRule { + get { + if ((this.CharRangeRuleField == null)) { + this.CharRangeRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharRangeRuleXName); + } + return this.CharRangeRuleField; + } + set { + if ((value == null)) { + this.CharRangeRuleField = null; + } + else { + if ((this.CharRangeRuleField == null)) { + this.CharRangeRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharRangeRuleXName); + } + else { + XTypedServices.SetList(this.CharRangeRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharSetRuleXName = System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharSetRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharSetRule { + get { + if ((this.CharSetRuleField == null)) { + this.CharSetRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharSetRuleXName); + } + return this.CharSetRuleField; + } + set { + if ((value == null)) { + this.CharSetRuleField = null; + } + else { + if ((this.CharSetRuleField == null)) { + this.CharSetRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharSetRuleXName); + } + else { + XTypedServices.SetList(this.CharSetRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CharRuleXName = System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CharRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRule { + get { + if ((this.CharRuleField == null)) { + this.CharRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CharRuleXName); + } + return this.CharRuleField; + } + set { + if ((value == null)) { + this.CharRuleField = null; + } + else { + if ((this.CharRuleField == null)) { + this.CharRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CharRuleXName); + } + else { + XTypedServices.SetList(this.CharRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName EndOfInputRuleXName = System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList EndOfInputRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList EndOfInputRule { + get { + if ((this.EndOfInputRuleField == null)) { + this.EndOfInputRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, EndOfInputRuleXName); + } + return this.EndOfInputRuleField; + } + set { + if ((value == null)) { + this.EndOfInputRuleField = null; + } + else { + if ((this.EndOfInputRuleField == null)) { + this.EndOfInputRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, EndOfInputRuleXName); + } + else { + XTypedServices.SetList(this.EndOfInputRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NodeRuleXName = System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NodeRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NodeRule { + get { + if ((this.NodeRuleField == null)) { + this.NodeRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NodeRuleXName); + } + return this.NodeRuleField; + } + set { + if ((value == null)) { + this.NodeRuleField = null; + } + else { + if ((this.NodeRuleField == null)) { + this.NodeRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NodeRuleXName); + } + else { + XTypedServices.SetList(this.NodeRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ZeroOrMoreRuleXName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList ZeroOrMoreRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ZeroOrMoreRule { + get { + if ((this.ZeroOrMoreRuleField == null)) { + this.ZeroOrMoreRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, ZeroOrMoreRuleXName); + } + return this.ZeroOrMoreRuleField; + } + set { + if ((value == null)) { + this.ZeroOrMoreRuleField = null; + } + else { + if ((this.ZeroOrMoreRuleField == null)) { + this.ZeroOrMoreRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, ZeroOrMoreRuleXName); + } + else { + XTypedServices.SetList(this.ZeroOrMoreRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OneOrMoreRuleXName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OneOrMoreRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OneOrMoreRule { + get { + if ((this.OneOrMoreRuleField == null)) { + this.OneOrMoreRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, OneOrMoreRuleXName); + } + return this.OneOrMoreRuleField; + } + set { + if ((value == null)) { + this.OneOrMoreRuleField = null; + } + else { + if ((this.OneOrMoreRuleField == null)) { + this.OneOrMoreRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OneOrMoreRuleXName); + } + else { + XTypedServices.SetList(this.OneOrMoreRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName CountedRuleXName = System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList CountedRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CountedRule { + get { + if ((this.CountedRuleField == null)) { + this.CountedRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, CountedRuleXName); + } + return this.CountedRuleField; + } + set { + if ((value == null)) { + this.CountedRuleField = null; + } + else { + if ((this.CountedRuleField == null)) { + this.CountedRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, CountedRuleXName); + } + else { + XTypedServices.SetList(this.CountedRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OptionalRuleXName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OptionalRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OptionalRule { + get { + if ((this.OptionalRuleField == null)) { + this.OptionalRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, OptionalRuleXName); + } + return this.OptionalRuleField; + } + set { + if ((value == null)) { + this.OptionalRuleField = null; + } + else { + if ((this.OptionalRuleField == null)) { + this.OptionalRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OptionalRuleXName); + } + else { + XTypedServices.SetList(this.OptionalRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName SequenceRuleXName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList SequenceRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList SequenceRule { + get { + if ((this.SequenceRuleField == null)) { + this.SequenceRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, SequenceRuleXName); + } + return this.SequenceRuleField; + } + set { + if ((value == null)) { + this.SequenceRuleField = null; + } + else { + if ((this.SequenceRuleField == null)) { + this.SequenceRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, SequenceRuleXName); + } + else { + XTypedServices.SetList(this.SequenceRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName ChoiceRuleXName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList ChoiceRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ChoiceRule { + get { + if ((this.ChoiceRuleField == null)) { + this.ChoiceRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, ChoiceRuleXName); + } + return this.ChoiceRuleField; + } + set { + if ((value == null)) { + this.ChoiceRuleField = null; + } + else { + if ((this.ChoiceRuleField == null)) { + this.ChoiceRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, ChoiceRuleXName); + } + else { + XTypedServices.SetList(this.ChoiceRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName AtRuleXName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList AtRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AtRule { + get { + if ((this.AtRuleField == null)) { + this.AtRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, AtRuleXName); + } + return this.AtRuleField; + } + set { + if ((value == null)) { + this.AtRuleField = null; + } + else { + if ((this.AtRuleField == null)) { + this.AtRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, AtRuleXName); + } + else { + XTypedServices.SetList(this.AtRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NotAtRuleXName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList NotAtRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NotAtRule { + get { + if ((this.NotAtRuleField == null)) { + this.NotAtRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, NotAtRuleXName); + } + return this.NotAtRuleField; + } + set { + if ((value == null)) { + this.NotAtRuleField = null; + } + else { + if ((this.NotAtRuleField == null)) { + this.NotAtRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, NotAtRuleXName); + } + else { + XTypedServices.SetList(this.NotAtRuleField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName OnFailXName = System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList OnFailField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OnFail { + get { + if ((this.OnFailField == null)) { + this.OnFailField = new XTypedList(this, LinqToXsdTypeManager.Instance, OnFailXName); + } + return this.OnFailField; + } + set { + if ((value == null)) { + this.OnFailField = null; + } + else { + if ((this.OnFailField == null)) { + this.OnFailField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, OnFailXName); + } + else { + XTypedServices.SetList(this.OnFailField, value); + } + } + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName BooleanRuleXName = System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedList BooleanRuleField; + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList BooleanRule { + get { + if ((this.BooleanRuleField == null)) { + this.BooleanRuleField = new XTypedList(this, LinqToXsdTypeManager.Instance, BooleanRuleXName); + } + return this.BooleanRuleField; + } + set { + if ((value == null)) { + this.BooleanRuleField = null; + } + else { + if ((this.BooleanRuleField == null)) { + this.BooleanRuleField = XTypedList.Initialize(this, LinqToXsdTypeManager.Instance, value, BooleanRuleXName); + } + else { + XTypedServices.SetList(this.BooleanRuleField, value); + } + } + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("MultiChildRule", "urn:ParaParse.XML"); + + static MultiChildRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName), new NamedContentModelEntity(RecursiveRuleXName), new NamedContentModelEntity(StringRuleXName), new NamedContentModelEntity(CaseInvariantStringRuleXName), new NamedContentModelEntity(AnyCharRuleXName), new NamedContentModelEntity(CharRangeRuleXName), new NamedContentModelEntity(CharSetRuleXName), new NamedContentModelEntity(CharRuleXName), new NamedContentModelEntity(EndOfInputRuleXName), new NamedContentModelEntity(NodeRuleXName), new NamedContentModelEntity(ZeroOrMoreRuleXName), new NamedContentModelEntity(OneOrMoreRuleXName), new NamedContentModelEntity(CountedRuleXName), new NamedContentModelEntity(OptionalRuleXName), new NamedContentModelEntity(SequenceRuleXName), new NamedContentModelEntity(ChoiceRuleXName), new NamedContentModelEntity(AtRuleXName), new NamedContentModelEntity(NotAtRuleXName), new NamedContentModelEntity(OnFailXName), new NamedContentModelEntity(BooleanRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + localElementDictionary.Add(RecursiveRuleXName, typeof(RecursiveRule)); + localElementDictionary.Add(StringRuleXName, typeof(StringRule)); + localElementDictionary.Add(CaseInvariantStringRuleXName, typeof(CaseInvariantStringRule)); + localElementDictionary.Add(AnyCharRuleXName, typeof(AnyCharRule)); + localElementDictionary.Add(CharRangeRuleXName, typeof(CharRangeRule)); + localElementDictionary.Add(CharSetRuleXName, typeof(CharSetRule)); + localElementDictionary.Add(CharRuleXName, typeof(CharRule)); + localElementDictionary.Add(EndOfInputRuleXName, typeof(EndOfInputRule)); + localElementDictionary.Add(NodeRuleXName, typeof(NodeRule)); + localElementDictionary.Add(ZeroOrMoreRuleXName, typeof(ZeroOrMoreRule)); + localElementDictionary.Add(OneOrMoreRuleXName, typeof(OneOrMoreRule)); + localElementDictionary.Add(CountedRuleXName, typeof(CountedRule)); + localElementDictionary.Add(OptionalRuleXName, typeof(OptionalRule)); + localElementDictionary.Add(SequenceRuleXName, typeof(SequenceRule)); + localElementDictionary.Add(ChoiceRuleXName, typeof(ChoiceRule)); + localElementDictionary.Add(AtRuleXName, typeof(AtRule)); + localElementDictionary.Add(NotAtRuleXName, typeof(NotAtRule)); + localElementDictionary.Add(OnFailXName, typeof(OnFail)); + localElementDictionary.Add(BooleanRuleXName, typeof(BooleanRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Fragment; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public abstract partial class Rule : XTypedElement, IXMetaData { + + public void Save(string xmlFile) { + XTypedServices.Save(xmlFile, Untyped); + } + + public void Save(System.IO.TextWriter tw) { + XTypedServices.Save(tw, Untyped); + } + + public void Save(System.Xml.XmlWriter xmlWriter) { + XTypedServices.Save(xmlWriter, Untyped); + } + + public static Rule Load(string xmlFile) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance))); + } + + public static Rule Load(System.IO.TextReader xmlFile) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance))); + } + + public static Rule Parse(string xml) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance))); + } + + public static explicit operator Rule(XElement xe) { return (Rule)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + protected Rule(bool setNull) { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private RuleType ContentField; + + public Rule() { + throw new InvalidOperationException(); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + if ((this.ContentField != null)) { + this.ContentField.Untyped = value; + } + } + } + + public virtual RuleType Content { + get { + return ContentField; + } + } + + private void SetInnerType(RuleType ContentField) { + this.ContentField = ((RuleType)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + } + + protected virtual void SetSubstitutionMember(RuleType ContentField) { + this.ContentField = ContentField; + } + + public Rule(RuleType content) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class ZeroOrMoreRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static ZeroOrMoreRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static ZeroOrMoreRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static ZeroOrMoreRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator ZeroOrMoreRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new ZeroOrMoreRule(((SingleChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private SingleChildRule ContentField; + + public ZeroOrMoreRule() : + base(true) { + SetInnerType(new SingleChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual SingleChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(SingleChildRule ContentField) { + this.ContentField = ((SingleChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public ZeroOrMoreRule(SingleChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule1 { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class OneOrMoreRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static OneOrMoreRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static OneOrMoreRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static OneOrMoreRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator OneOrMoreRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new OneOrMoreRule(((SingleChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private SingleChildRule ContentField; + + public OneOrMoreRule() : + base(true) { + SetInnerType(new SingleChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual SingleChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(SingleChildRule ContentField) { + this.ContentField = ((SingleChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public OneOrMoreRule(SingleChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule1 { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class OptionalRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static OptionalRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static OptionalRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static OptionalRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator OptionalRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new OptionalRule(((SingleChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private SingleChildRule ContentField; + + public OptionalRule() : + base(true) { + SetInnerType(new SingleChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual SingleChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(SingleChildRule ContentField) { + this.ContentField = ((SingleChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public OptionalRule(SingleChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule1 { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class SequenceRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static SequenceRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static SequenceRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static SequenceRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator SequenceRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new SequenceRule(((MultiChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private MultiChildRule ContentField; + + public SequenceRule() : + base(true) { + SetInnerType(new MultiChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual MultiChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(MultiChildRule ContentField) { + this.ContentField = ((MultiChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public SequenceRule(MultiChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList SequenceRule1 { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class ChoiceRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static ChoiceRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static ChoiceRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static ChoiceRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator ChoiceRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new ChoiceRule(((MultiChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private MultiChildRule ContentField; + + public ChoiceRule() : + base(true) { + SetInnerType(new MultiChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual MultiChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(MultiChildRule ContentField) { + this.ContentField = ((MultiChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public ChoiceRule(MultiChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList ChoiceRule1 { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule))* + /// + /// + public virtual IList BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class AtRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static AtRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static AtRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static AtRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator AtRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new AtRule(((SingleChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private SingleChildRule ContentField; + + public AtRule() : + base(true) { + SetInnerType(new SingleChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual SingleChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(SingleChildRule ContentField) { + this.ContentField = ((SingleChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public AtRule(SingleChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule1 { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public partial class NotAtRule : global::ParaParse.Xml.Rule, IXMetaData { + + public new static NotAtRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public static NotAtRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile, LinqToXsdTypeManager.Instance); + } + + public new static NotAtRule Parse(string xml) { + return XTypedServices.Parse(xml, LinqToXsdTypeManager.Instance); + } + + public static explicit operator NotAtRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return new NotAtRule(((SingleChildRule)(this.Content.Clone()))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private SingleChildRule ContentField; + + public NotAtRule() : + base(true) { + SetInnerType(new SingleChildRule()); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + this.ContentField.Untyped = value; + } + } + + public new virtual SingleChildRule Content { + get { + return ContentField; + } + } + + private void SetInnerType(SingleChildRule ContentField) { + this.ContentField = ((SingleChildRule)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + base.SetSubstitutionMember(ContentField); + } + + public NotAtRule(SingleChildRule content) : + base(true) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + return this.ContentField.NamedRule; + } + set { + this.ContentField.NamedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual RecursiveRule RecursiveRule { + get { + return this.ContentField.RecursiveRule; + } + set { + this.ContentField.RecursiveRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual StringRule StringRule { + get { + return this.ContentField.StringRule; + } + set { + this.ContentField.StringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CaseInvariantStringRule CaseInvariantStringRule { + get { + return this.ContentField.CaseInvariantStringRule; + } + set { + this.ContentField.CaseInvariantStringRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AnyCharRule AnyCharRule { + get { + return this.ContentField.AnyCharRule; + } + set { + this.ContentField.AnyCharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRangeRule CharRangeRule { + get { + return this.ContentField.CharRangeRule; + } + set { + this.ContentField.CharRangeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharSetRule CharSetRule { + get { + return this.ContentField.CharSetRule; + } + set { + this.ContentField.CharSetRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CharRule CharRule { + get { + return this.ContentField.CharRule; + } + set { + this.ContentField.CharRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual EndOfInputRule EndOfInputRule { + get { + return this.ContentField.EndOfInputRule; + } + set { + this.ContentField.EndOfInputRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NodeRule NodeRule { + get { + return this.ContentField.NodeRule; + } + set { + this.ContentField.NodeRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ZeroOrMoreRule ZeroOrMoreRule { + get { + return this.ContentField.ZeroOrMoreRule; + } + set { + this.ContentField.ZeroOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OneOrMoreRule OneOrMoreRule { + get { + return this.ContentField.OneOrMoreRule; + } + set { + this.ContentField.OneOrMoreRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual CountedRule CountedRule { + get { + return this.ContentField.CountedRule; + } + set { + this.ContentField.CountedRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OptionalRule OptionalRule { + get { + return this.ContentField.OptionalRule; + } + set { + this.ContentField.OptionalRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual SequenceRule SequenceRule { + get { + return this.ContentField.SequenceRule; + } + set { + this.ContentField.SequenceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual ChoiceRule ChoiceRule { + get { + return this.ContentField.ChoiceRule; + } + set { + this.ContentField.ChoiceRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual AtRule AtRule { + get { + return this.ContentField.AtRule; + } + set { + this.ContentField.AtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual NotAtRule NotAtRule1 { + get { + return this.ContentField.NotAtRule; + } + set { + this.ContentField.NotAtRule = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual OnFail OnFail { + get { + return this.ContentField.OnFail; + } + set { + this.ContentField.OnFail = value; + } + } + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule | RecursiveRule | StringRule | CaseInvariantStringRule | AnyCharRule | CharRangeRule | CharSetRule | CharRule | EndOfInputRule | NodeRule | ZeroOrMoreRule | OneOrMoreRule | CountedRule | OptionalRule | SequenceRule | ChoiceRule | AtRule | NotAtRule | OnFail | BooleanRule)) + /// + /// + public virtual BooleanRule BooleanRule { + get { + return this.ContentField.BooleanRule; + } + set { + this.ContentField.BooleanRule = value; + } + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public class LinqToXsdTypeManager : ILinqToXsdTypeManager { + + private LinqToXsdTypeManager() { + } + + private static Dictionary typeDictionary = new Dictionary(); + + private static void BuildTypeDictionary() { + typeDictionary.Add(System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.RuleType)); + typeDictionary.Add(System.Xml.Linq.XName.Get("SingleChildRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.SingleChildRule)); + typeDictionary.Add(System.Xml.Linq.XName.Get("MultiChildRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.MultiChildRule)); + } + + private static Dictionary elementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + elementDictionary.Add(System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.NamedRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("RecursiveRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.RecursiveRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("StringRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.StringRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("CaseInvariantStringRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.CaseInvariantStringRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("AnyCharRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.AnyCharRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("CharRangeRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.CharRangeRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("CharSetRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.CharSetRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("CharRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.CharRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("EndOfInputRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.EndOfInputRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("NodeRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.NodeRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("CountedRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.CountedRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("OnFail", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.OnFail)); + elementDictionary.Add(System.Xml.Linq.XName.Get("BooleanRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.BooleanRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("grammar", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.grammar)); + elementDictionary.Add(System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.Rule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("ZeroOrMoreRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.ZeroOrMoreRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("OneOrMoreRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.OneOrMoreRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("OptionalRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.OptionalRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("SequenceRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.SequenceRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("ChoiceRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.ChoiceRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("AtRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.AtRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("NotAtRule", "urn:ParaParse.XML"), typeof(global::ParaParse.Xml.NotAtRule)); + } + + private static Dictionary wrapperDictionary = new Dictionary(); + + private static void BuildWrapperDictionary() { + wrapperDictionary.Add(typeof(ParaParse.Xml.Rule), typeof(global::ParaParse.Xml.RuleType)); + wrapperDictionary.Add(typeof(ParaParse.Xml.ZeroOrMoreRule), typeof(global::ParaParse.Xml.SingleChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.OneOrMoreRule), typeof(global::ParaParse.Xml.SingleChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.OptionalRule), typeof(global::ParaParse.Xml.SingleChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.SequenceRule), typeof(global::ParaParse.Xml.MultiChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.ChoiceRule), typeof(global::ParaParse.Xml.MultiChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.AtRule), typeof(global::ParaParse.Xml.SingleChildRule)); + wrapperDictionary.Add(typeof(ParaParse.Xml.NotAtRule), typeof(global::ParaParse.Xml.SingleChildRule)); + } + + private static XmlSchemaSet schemaSet; + + XmlSchemaSet ILinqToXsdTypeManager.Schemas { + get { + if ((schemaSet == null)) { + XmlSchemaSet tempSet = new XmlSchemaSet(); + System.Threading.Interlocked.CompareExchange(ref schemaSet, tempSet, null); + } + return schemaSet; + } + set { + schemaSet = value; + } + } + + protected internal static void AddSchemas(XmlSchemaSet schemas) { + schemas.Add(schemaSet); + } + + Dictionary ILinqToXsdTypeManager.GlobalTypeDictionary { + get { + return typeDictionary; + } + } + + Dictionary ILinqToXsdTypeManager.GlobalElementDictionary { + get { + return elementDictionary; + } + } + + Dictionary ILinqToXsdTypeManager.RootContentTypeMapping { + get { + return wrapperDictionary; + } + } + + static LinqToXsdTypeManager() { + BuildTypeDictionary(); + BuildElementDictionary(); + BuildWrapperDictionary(); + } + + public static System.Type GetRootType() { + return elementDictionary[System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML")]; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static LinqToXsdTypeManager typeManagerSingleton = new LinqToXsdTypeManager(); + + public static LinqToXsdTypeManager Instance { + get { + return typeManagerSingleton; + } + } + } + + public partial class XRootNamespace { + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XDocument doc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedElement rootObject; + + private XRootNamespace() { + } + + public static XRootNamespace Load(string xmlFile) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlFile); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(string xmlFile, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlFile, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(TextReader textReader) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(textReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(TextReader textReader, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(textReader, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(XmlReader xmlReader) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Parse(string text) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Parse(text); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Parse(string text, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Parse(text, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public virtual void Save(string fileName) { + doc.Save(fileName); + } + + public virtual void Save(TextWriter textWriter) { + doc.Save(textWriter); + } + + public virtual void Save(XmlWriter writer) { + doc.Save(writer); + } + + public virtual void Save(TextWriter textWriter, SaveOptions options) { + doc.Save(textWriter, options); + } + + public virtual void Save(string fileName, SaveOptions options) { + doc.Save(fileName, options); + } + + public virtual XDocument XDocument { + get { + return doc; + } + } + + public virtual XTypedElement Root { + get { + return rootObject; + } + } + + public XRootNamespace(NamedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public NamedRule NamedRule { get {return rootObject as NamedRule; } } + + public XRootNamespace(RecursiveRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public RecursiveRule RecursiveRule { get {return rootObject as RecursiveRule; } } + + public XRootNamespace(StringRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public StringRule StringRule { get {return rootObject as StringRule; } } + + public XRootNamespace(CaseInvariantStringRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public CaseInvariantStringRule CaseInvariantStringRule { get {return rootObject as CaseInvariantStringRule; } } + + public XRootNamespace(AnyCharRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public AnyCharRule AnyCharRule { get {return rootObject as AnyCharRule; } } + + public XRootNamespace(CharRangeRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public CharRangeRule CharRangeRule { get {return rootObject as CharRangeRule; } } + + public XRootNamespace(CharSetRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public CharSetRule CharSetRule { get {return rootObject as CharSetRule; } } + + public XRootNamespace(CharRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public CharRule CharRule { get {return rootObject as CharRule; } } + + public XRootNamespace(EndOfInputRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public EndOfInputRule EndOfInputRule { get {return rootObject as EndOfInputRule; } } + + public XRootNamespace(NodeRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public NodeRule NodeRule { get {return rootObject as NodeRule; } } + + public XRootNamespace(CountedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public CountedRule CountedRule { get {return rootObject as CountedRule; } } + + public XRootNamespace(OnFail root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public OnFail OnFail { get {return rootObject as OnFail; } } + + public XRootNamespace(BooleanRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public BooleanRule BooleanRule { get {return rootObject as BooleanRule; } } + + public XRootNamespace(grammar root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public grammar grammar { get {return rootObject as grammar; } } + + public XRootNamespace(Rule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public Rule Rule { get {return rootObject as Rule; } } + + public XRootNamespace(ZeroOrMoreRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public ZeroOrMoreRule ZeroOrMoreRule { get {return rootObject as ZeroOrMoreRule; } } + + public XRootNamespace(OneOrMoreRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public OneOrMoreRule OneOrMoreRule { get {return rootObject as OneOrMoreRule; } } + + public XRootNamespace(OptionalRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public OptionalRule OptionalRule { get {return rootObject as OptionalRule; } } + + public XRootNamespace(SequenceRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public SequenceRule SequenceRule { get {return rootObject as SequenceRule; } } + + public XRootNamespace(ChoiceRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public ChoiceRule ChoiceRule { get {return rootObject as ChoiceRule; } } + + public XRootNamespace(AtRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public AtRule AtRule { get {return rootObject as AtRule; } } + + public XRootNamespace(NotAtRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public NotAtRule NotAtRule { get {return rootObject as NotAtRule; } } + } + + public partial class XRoot { + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XDocument doc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedElement rootObject; + + private XRoot() { + } + + public static XRoot Load(string xmlFile) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlFile); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(string xmlFile, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlFile, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(TextReader textReader) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(textReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(TextReader textReader, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(textReader, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(XmlReader xmlReader) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Parse(string text) { + XRoot root = new XRoot(); + root.doc = XDocument.Parse(text); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Parse(string text, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Parse(text, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public virtual void Save(string fileName) { + doc.Save(fileName); + } + + public virtual void Save(TextWriter textWriter) { + doc.Save(textWriter); + } + + public virtual void Save(XmlWriter writer) { + doc.Save(writer); + } + + public virtual void Save(TextWriter textWriter, SaveOptions options) { + doc.Save(textWriter, options); + } + + public virtual void Save(string fileName, SaveOptions options) { + doc.Save(fileName, options); + } + + public virtual XDocument XDocument { + get { + return doc; + } + } + + public virtual XTypedElement Root { + get { + return rootObject; + } + } + + public XRoot(global::ParaParse.Xml.NamedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.NamedRule NamedRule { get {return rootObject as global::ParaParse.Xml.NamedRule; } } + + public XRoot(global::ParaParse.Xml.RecursiveRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.RecursiveRule RecursiveRule { get {return rootObject as global::ParaParse.Xml.RecursiveRule; } } + + public XRoot(global::ParaParse.Xml.StringRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.StringRule StringRule { get {return rootObject as global::ParaParse.Xml.StringRule; } } + + public XRoot(global::ParaParse.Xml.CaseInvariantStringRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.CaseInvariantStringRule CaseInvariantStringRule { get {return rootObject as global::ParaParse.Xml.CaseInvariantStringRule; } } + + public XRoot(global::ParaParse.Xml.AnyCharRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.AnyCharRule AnyCharRule { get {return rootObject as global::ParaParse.Xml.AnyCharRule; } } + + public XRoot(global::ParaParse.Xml.CharRangeRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.CharRangeRule CharRangeRule { get {return rootObject as global::ParaParse.Xml.CharRangeRule; } } + + public XRoot(global::ParaParse.Xml.CharSetRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.CharSetRule CharSetRule { get {return rootObject as global::ParaParse.Xml.CharSetRule; } } + + public XRoot(global::ParaParse.Xml.CharRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.CharRule CharRule { get {return rootObject as global::ParaParse.Xml.CharRule; } } + + public XRoot(global::ParaParse.Xml.EndOfInputRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.EndOfInputRule EndOfInputRule { get {return rootObject as global::ParaParse.Xml.EndOfInputRule; } } + + public XRoot(global::ParaParse.Xml.NodeRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.NodeRule NodeRule { get {return rootObject as global::ParaParse.Xml.NodeRule; } } + + public XRoot(global::ParaParse.Xml.CountedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.CountedRule CountedRule { get {return rootObject as global::ParaParse.Xml.CountedRule; } } + + public XRoot(global::ParaParse.Xml.OnFail root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.OnFail OnFail { get {return rootObject as global::ParaParse.Xml.OnFail; } } + + public XRoot(global::ParaParse.Xml.BooleanRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.BooleanRule BooleanRule { get {return rootObject as global::ParaParse.Xml.BooleanRule; } } + + public XRoot(global::ParaParse.Xml.grammar root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.grammar grammar { get {return rootObject as global::ParaParse.Xml.grammar; } } + + public XRoot(global::ParaParse.Xml.Rule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.Rule Rule { get {return rootObject as global::ParaParse.Xml.Rule; } } + + public XRoot(global::ParaParse.Xml.ZeroOrMoreRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.ZeroOrMoreRule ZeroOrMoreRule { get {return rootObject as global::ParaParse.Xml.ZeroOrMoreRule; } } + + public XRoot(global::ParaParse.Xml.OneOrMoreRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.OneOrMoreRule OneOrMoreRule { get {return rootObject as global::ParaParse.Xml.OneOrMoreRule; } } + + public XRoot(global::ParaParse.Xml.OptionalRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.OptionalRule OptionalRule { get {return rootObject as global::ParaParse.Xml.OptionalRule; } } + + public XRoot(global::ParaParse.Xml.SequenceRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.SequenceRule SequenceRule { get {return rootObject as global::ParaParse.Xml.SequenceRule; } } + + public XRoot(global::ParaParse.Xml.ChoiceRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.ChoiceRule ChoiceRule { get {return rootObject as global::ParaParse.Xml.ChoiceRule; } } + + public XRoot(global::ParaParse.Xml.AtRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.AtRule AtRule { get {return rootObject as global::ParaParse.Xml.AtRule; } } + + public XRoot(global::ParaParse.Xml.NotAtRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::ParaParse.Xml.NotAtRule NotAtRule { get {return rootObject as global::ParaParse.Xml.NotAtRule; } } + } +} diff --git a/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd b/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd new file mode 100644 index 00000000..ae575b1a --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd.cs b/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd.cs new file mode 100644 index 00000000..e89d2f94 --- /dev/null +++ b/GeneratedSchemaLibraries/ParaParserXml/paraparse_xNameBug.xsd.cs @@ -0,0 +1,765 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace urn.ParaParse.XML { + using System; + using System.Collections; + using System.Collections.Generic; + using System.ComponentModel; + using System.IO; + using System.Linq; + using System.Diagnostics; + using System.Xml; + using System.Xml.Schema; + using System.Xml.Linq; + using Xml.Schema.Linq; + + + /// + /// + /// Regular expression: ((NamedRule1)) + /// + /// + public partial class NamedRule : global::urn.ParaParse.XML.Rule, IXMetaData { + + public new static NamedRule Load(string xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public static NamedRule Load(System.IO.TextReader xmlFile) { + return XTypedServices.Load(xmlFile); + } + + public new static NamedRule Parse(string xml) { + return XTypedServices.Parse(xml); + } + + public static explicit operator NamedRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule1)) + /// + /// + public NamedRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRule1XName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName RuleNameXName = System.Xml.Linq.XName.Get("RuleName", ""); + + /// + /// + /// Occurrence: required + /// + /// + public virtual string RuleName { + get { + XAttribute x = this.Attribute(RuleNameXName); + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(RuleNameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + static NamedRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRule1XName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRule1XName, typeof(NamedRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public abstract partial class RuleType : XTypedElement, IXMetaData { + + public static explicit operator RuleType(XElement xe) { return (RuleType)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public RuleType() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NameXName = System.Xml.Linq.XName.Get("Name", ""); + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + XAttribute x = this.Attribute(NameXName); + if ((x == null)) { + return null; + } + return XTypedServices.ParseValue(x, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + set { + this.SetAttribute(NameXName, value, XmlSchemaType.GetBuiltInSimpleType(XmlTypeCode.String).Datatype); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"); + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Fragment; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + /// + /// + /// Regular expression: ((NamedRule)) + /// + /// + public partial class SingleChildRule : global::urn.ParaParse.XML.RuleType, IXMetaData { + + public static explicit operator SingleChildRule(XElement xe) { return XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + public override XTypedElement Clone() { + return XTypedServices.CloneXTypedElement(this); + } + + /// + /// + /// Regular expression: ((NamedRule)) + /// + /// + public SingleChildRule() { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + [EditorBrowsable(EditorBrowsableState.Never)] + protected internal static readonly System.Xml.Linq.XName NamedRuleXName = System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"); + + /// + /// + /// Occurrence: required, choice + /// + /// + /// Setter: Appends + /// + /// + /// Regular expression: ((NamedRule)) + /// + /// + public virtual NamedRule NamedRule { + get { + XElement x = this.GetElement(NamedRuleXName); + if ((x == null)) { + return null; + } + return ((NamedRule)(x)); + } + set { + this.SetElement(NamedRuleXName, value); + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("SingleChildRule", "urn:ParaParse.XML"); + + static SingleChildRule() { + BuildElementDictionary(); + contentModel = new SequenceContentModelEntity(new ChoiceContentModelEntity(new NamedContentModelEntity(NamedRuleXName))); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static Dictionary localElementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + localElementDictionary.Add(NamedRuleXName, typeof(NamedRule)); + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + Dictionary IXMetaData.LocalElementsDictionary { + get { + return localElementDictionary; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static ContentModelEntity contentModel; + + ContentModelEntity IXMetaData.GetContentModel() { + return contentModel; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Fragment; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public abstract partial class Rule : XTypedElement, IXMetaData { + + public void Save(string xmlFile) { + XTypedServices.Save(xmlFile, Untyped); + } + + public void Save(System.IO.TextWriter tw) { + XTypedServices.Save(tw, Untyped); + } + + public void Save(System.Xml.XmlWriter xmlWriter) { + XTypedServices.Save(xmlWriter, Untyped); + } + + public static Rule Load(string xmlFile) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance))); + } + + public static Rule Load(System.IO.TextReader xmlFile) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Load(xmlFile), LinqToXsdTypeManager.Instance))); + } + + public static Rule Parse(string xml) { + return ((Rule)(XTypedServices.ToXTypedElement(XElement.Parse(xml), LinqToXsdTypeManager.Instance))); + } + + public static explicit operator Rule(XElement xe) { return (Rule)XTypedServices.ToXTypedElement(xe,LinqToXsdTypeManager.Instance as ILinqToXsdTypeManager); } + + protected Rule(bool setNull) { + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private RuleType ContentField; + + public Rule() { + throw new InvalidOperationException(); + } + + public override XElement Untyped { + get { + return base.Untyped; + } + set { + base.Untyped = value; + if ((this.ContentField != null)) { + this.ContentField.Untyped = value; + } + } + } + + public virtual RuleType Content { + get { + return ContentField; + } + } + + private void SetInnerType(RuleType ContentField) { + this.ContentField = ((RuleType)(XTypedServices.GetCloneIfRooted(ContentField))); + XTypedServices.SetName(this, this.ContentField); + } + + protected virtual void SetSubstitutionMember(RuleType ContentField) { + this.ContentField = ContentField; + } + + public Rule(RuleType content) { + SetInnerType(content); + } + + /// + /// + /// Occurrence: optional + /// + /// + public virtual string Name { + get { + return this.ContentField.Name; + } + set { + this.ContentField.Name = value; + } + } + + private static readonly System.Xml.Linq.XName xName = System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"); + + Dictionary IXMetaData.LocalElementsDictionary { + get { + IXMetaData schemaMetaData = ((IXMetaData)(this.Content)); + return schemaMetaData.LocalElementsDictionary; + } + } + + XTypedElement IXMetaData.Content { + get { + return this.Content; + } + } + + ContentModelEntity IXMetaData.GetContentModel() { + return ContentModelEntity.Default; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + System.Xml.Linq.XName IXMetaData.SchemaName { + get { + return xName; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + SchemaOrigin IXMetaData.TypeOrigin { + get { + return SchemaOrigin.Element; + } + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + ILinqToXsdTypeManager IXMetaData.TypeManager { + get { + return LinqToXsdTypeManager.Instance; + } + } + } + + public class LinqToXsdTypeManager : ILinqToXsdTypeManager { + + private LinqToXsdTypeManager() { + } + + private static Dictionary typeDictionary = new Dictionary(); + + private static void BuildTypeDictionary() { + typeDictionary.Add(System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"), typeof(global::urn.ParaParse.XML.RuleType)); + typeDictionary.Add(System.Xml.Linq.XName.Get("SingleChildRule", "urn:ParaParse.XML"), typeof(global::urn.ParaParse.XML.SingleChildRule)); + } + + private static Dictionary elementDictionary = new Dictionary(); + + private static void BuildElementDictionary() { + elementDictionary.Add(System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML"), typeof(global::urn.ParaParse.XML.NamedRule)); + elementDictionary.Add(System.Xml.Linq.XName.Get("Rule", "urn:ParaParse.XML"), typeof(global::urn.ParaParse.XML.Rule)); + } + + private static Dictionary wrapperDictionary = new Dictionary(); + + private static void BuildWrapperDictionary() { + wrapperDictionary.Add(typeof(urn.ParaParse.XML.Rule), typeof(global::urn.ParaParse.XML.RuleType)); + } + + private static XmlSchemaSet schemaSet; + + XmlSchemaSet ILinqToXsdTypeManager.Schemas { + get { + if ((schemaSet == null)) { + XmlSchemaSet tempSet = new XmlSchemaSet(); + System.Threading.Interlocked.CompareExchange(ref schemaSet, tempSet, null); + } + return schemaSet; + } + set { + schemaSet = value; + } + } + + protected internal static void AddSchemas(XmlSchemaSet schemas) { + schemas.Add(schemaSet); + } + + Dictionary ILinqToXsdTypeManager.GlobalTypeDictionary { + get { + return typeDictionary; + } + } + + Dictionary ILinqToXsdTypeManager.GlobalElementDictionary { + get { + return elementDictionary; + } + } + + Dictionary ILinqToXsdTypeManager.RootContentTypeMapping { + get { + return wrapperDictionary; + } + } + + static LinqToXsdTypeManager() { + BuildTypeDictionary(); + BuildElementDictionary(); + BuildWrapperDictionary(); + } + + public static System.Type GetRootType() { + return elementDictionary[System.Xml.Linq.XName.Get("NamedRule", "urn:ParaParse.XML")]; + } + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private static LinqToXsdTypeManager typeManagerSingleton = new LinqToXsdTypeManager(); + + public static LinqToXsdTypeManager Instance { + get { + return typeManagerSingleton; + } + } + } + + public partial class XRootNamespace { + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XDocument doc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedElement rootObject; + + private XRootNamespace() { + } + + public static XRootNamespace Load(string xmlFile) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlFile); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(string xmlFile, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlFile, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(TextReader textReader) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(textReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(TextReader textReader, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(textReader, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Load(XmlReader xmlReader) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Load(xmlReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Parse(string text) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Parse(text); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRootNamespace Parse(string text, LoadOptions options) { + XRootNamespace root = new XRootNamespace(); + root.doc = XDocument.Parse(text, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public virtual void Save(string fileName) { + doc.Save(fileName); + } + + public virtual void Save(TextWriter textWriter) { + doc.Save(textWriter); + } + + public virtual void Save(XmlWriter writer) { + doc.Save(writer); + } + + public virtual void Save(TextWriter textWriter, SaveOptions options) { + doc.Save(textWriter, options); + } + + public virtual void Save(string fileName, SaveOptions options) { + doc.Save(fileName, options); + } + + public virtual XDocument XDocument { + get { + return doc; + } + } + + public virtual XTypedElement Root { + get { + return rootObject; + } + } + + public XRootNamespace(NamedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public NamedRule NamedRule { get {return rootObject as NamedRule; } } + + public XRootNamespace(Rule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public Rule Rule { get {return rootObject as Rule; } } + } + + public partial class XRoot { + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XDocument doc; + + [DebuggerBrowsable(DebuggerBrowsableState.Never)] + private XTypedElement rootObject; + + private XRoot() { + } + + public static XRoot Load(string xmlFile) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlFile); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(string xmlFile, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlFile, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(TextReader textReader) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(textReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(TextReader textReader, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(textReader, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Load(XmlReader xmlReader) { + XRoot root = new XRoot(); + root.doc = XDocument.Load(xmlReader); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Parse(string text) { + XRoot root = new XRoot(); + root.doc = XDocument.Parse(text); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public static XRoot Parse(string text, LoadOptions options) { + XRoot root = new XRoot(); + root.doc = XDocument.Parse(text, options); + XTypedElement typedRoot = XTypedServices.ToXTypedElement(root.doc.Root, LinqToXsdTypeManager.Instance); + if ((typedRoot == null)) { + throw new LinqToXsdException("Invalid root element in xml document."); + } + root.rootObject = typedRoot; + return root; + } + + public virtual void Save(string fileName) { + doc.Save(fileName); + } + + public virtual void Save(TextWriter textWriter) { + doc.Save(textWriter); + } + + public virtual void Save(XmlWriter writer) { + doc.Save(writer); + } + + public virtual void Save(TextWriter textWriter, SaveOptions options) { + doc.Save(textWriter, options); + } + + public virtual void Save(string fileName, SaveOptions options) { + doc.Save(fileName, options); + } + + public virtual XDocument XDocument { + get { + return doc; + } + } + + public virtual XTypedElement Root { + get { + return rootObject; + } + } + + public XRoot(global::urn.ParaParse.XML.NamedRule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::urn.ParaParse.XML.NamedRule NamedRule { get {return rootObject as global::urn.ParaParse.XML.NamedRule; } } + + public XRoot(global::urn.ParaParse.XML.Rule root) { + this.doc = new XDocument(root.Untyped); + this.rootObject = root; + } + + + public global::urn.ParaParse.XML.Rule Rule { get {return rootObject as global::urn.ParaParse.XML.Rule; } } + } +} diff --git a/LinqToXsd-TestingSuite.slnf b/LinqToXsd-TestingSuite.slnf index 3cfd2d56..b20e81a6 100644 --- a/LinqToXsd-TestingSuite.slnf +++ b/LinqToXsd-TestingSuite.slnf @@ -38,6 +38,7 @@ "GeneratedSchemaLibraries\\OpenPackagingConventions-XMLSchema\\OpenPackagingConventions-XMLSchema.csproj", "GeneratedSchemaLibraries\\Opml\\Opml.csproj", "GeneratedSchemaLibraries\\Pubmed\\Pubmed.csproj", + "GeneratedSchemaLibraries\\ParaParserXml\\ParaParserXml.csproj", "GeneratedSchemaLibraries\\Rss\\Rss.csproj", "GeneratedSchemaLibraries\\SBML\\SBML.csproj", "GeneratedSchemaLibraries\\SWRL\\SWRL.csproj", diff --git a/LinqToXsd/Properties/launchSettings.json b/LinqToXsd/Properties/launchSettings.json index 4a756517..7bd69adc 100644 --- a/LinqToXsd/Properties/launchSettings.json +++ b/LinqToXsd/Properties/launchSettings.json @@ -242,6 +242,12 @@ "commandLineArgs": "gen -a .\\basic\\ruleml.xsd", "workingDirectory": "..\\GeneratedSchemaLibraries\\LegalRuleML", "hotReloadEnabled": false + }, + "ParaParse": { + "commandName": "Project", + "commandLineArgs": "gen -a .\\paraparse.xsd", + "workingDirectory": "..\\GeneratedSchemaLibraries\\ParaParserXml", + "hotReloadEnabled": false } } } \ No newline at end of file diff --git a/LinqToXsdCore.sln b/LinqToXsdCore.sln index e4fd3600..4938680d 100644 --- a/LinqToXsdCore.sln +++ b/LinqToXsdCore.sln @@ -1,7 +1,7 @@  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 18 -VisualStudioVersion = 18.2.11415.280 d18.0 +VisualStudioVersion = 18.2.11415.280 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "XObjectsCore", "XObjectsCore\XObjectsCore.csproj", "{71210419-4EA9-442B-ACA2-4FCD647929E3}" EndProject @@ -152,6 +152,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NestedChoiceTest", "Generat EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Expression.Media.Catalog", "GeneratedSchemaLibraries\Microsoft.Expression.Media.Catalog\Microsoft.Expression.Media.Catalog.csproj", "{19AB6A3F-52F0-A9A4-5B41-F66F7D6B2261}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ParaParserXml", "GeneratedSchemaLibraries\ParaParserXml\ParaParserXml.csproj", "{5442DAC6-56E8-4B25-4399-45432CB2C1A3}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -422,6 +424,10 @@ Global {19AB6A3F-52F0-A9A4-5B41-F66F7D6B2261}.Debug|Any CPU.Build.0 = Debug|Any CPU {19AB6A3F-52F0-A9A4-5B41-F66F7D6B2261}.Release|Any CPU.ActiveCfg = Release|Any CPU {19AB6A3F-52F0-A9A4-5B41-F66F7D6B2261}.Release|Any CPU.Build.0 = Release|Any CPU + {5442DAC6-56E8-4B25-4399-45432CB2C1A3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5442DAC6-56E8-4B25-4399-45432CB2C1A3}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5442DAC6-56E8-4B25-4399-45432CB2C1A3}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5442DAC6-56E8-4B25-4399-45432CB2C1A3}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -488,6 +494,7 @@ Global {1ED7C587-FF83-F2D8-9D29-3BA33170ED67} = {E65C7EC3-E7E2-46C0-83E1-BFD629ED6C6D} {962829C6-2FA5-696D-CE78-2DA01452F385} = {E65C7EC3-E7E2-46C0-83E1-BFD629ED6C6D} {19AB6A3F-52F0-A9A4-5B41-F66F7D6B2261} = {E65C7EC3-E7E2-46C0-83E1-BFD629ED6C6D} + {5442DAC6-56E8-4B25-4399-45432CB2C1A3} = {E65C7EC3-E7E2-46C0-83E1-BFD629ED6C6D} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {515FF9D5-932D-4E95-A20B-E2A06A52858F} diff --git a/RELEASENOTES.md b/RELEASENOTES.md index 6ad72ac5..53e73947 100644 --- a/RELEASENOTES.md +++ b/RELEASENOTES.md @@ -1,5 +1,13 @@ # LinqToXsdCore Release Notes +## Version 3.4.16 +Nuget packages: +* https://www.nuget.org/packages/LinqToXsdCore/3.4.16 +* https://www.nuget.org/packages/XObjectsCore/3.4.16 + * [#90](https://github.com/mamift/LinqToXsdCore/pull/90). + * When a user specified CLR namespace ends with System or Xml, then the `using` directives in the generated code will now start with `global::`` to prevent namespace resolution errors and uncompilable code. + * Fixed a code gen issue when an element definition is of a type that itself inherits from another type, the static `XName` fields that are usually generated for properties that are part of the element's content model, do not get generated at all. These are part of the element dictionary (`BuildElementDictionary()`) which is called in the static constructor for the that element class. This bug affects `XObjectsCodeGen`. Affected code generation for *paraparse.xsd*. + ## Version 3.4.15 Nuget packages: * https://www.nuget.org/packages/LinqToXsdCore/3.4.15 @@ -226,4 +234,4 @@ Nuget packages: * https://www.nuget.org/packages/XObjectsCore/3.0.0.4 * https://www.nuget.org/packages/LinqToXsdCore/3.0.0.6 -Fixes a bug that caused XTypedElement.Clone() to fail when generated code had the `internal` visibility modifier. This manifested in the CLI tool, when attempting to use it to generate an example configuration file `linqtoxsd config 'file.xsd' -e`. \ No newline at end of file +Fixes a bug that caused XTypedElement.Clone() to fail when generated code had the `internal` visibility modifier. This manifested in the CLI tool, when attempting to use it to generate an example configuration file `linqtoxsd config 'file.xsd' -e`. diff --git a/Version.props b/Version.props index c851ae6b..dd5e3806 100644 --- a/Version.props +++ b/Version.props @@ -1,6 +1,6 @@ - 3.4.15 + 3.4.16 $(VersionSuffix) $(Version)-$(VersionSuffix) diff --git a/XObjectsCode/Src/NameMangler.cs b/XObjectsCode/Src/NameMangler.cs index 706b996f..4c5fcda3 100644 --- a/XObjectsCode/Src/NameMangler.cs +++ b/XObjectsCode/Src/NameMangler.cs @@ -9,6 +9,7 @@ using System.Threading; using System.Xml.Serialization; using System.Globalization; +using System.Linq; namespace Xml.Schema.Linq.CodeGen { @@ -201,6 +202,30 @@ public bool isNameFixed() } } + internal class SymbolIdentifier + { + public string Identifier { get; } + public int IncrementNumber { get; } + + public SymbolIdentifier(string identifier, int incrementNumber = 0) + { + Identifier = identifier ?? throw new ArgumentNullException(nameof(identifier)); + IncrementNumber = incrementNumber; + } + + public override string ToString() + { + if (IncrementNumber > 0) { + return $"{Identifier}{IncrementNumber}"; + } + + return Identifier; + } + + public static implicit operator SymbolIdentifier(string identifier) => new SymbolIdentifier(identifier); + public static implicit operator string(SymbolIdentifier symbolId) => symbolId.ToString(); + } + internal class GlobalSymbolTable { internal Dictionary symbols; @@ -306,7 +331,8 @@ public string AddLocalElement(XmlSchemaElement element) if (identifierName != null) return identifierName; identifierName = NameGenerator.MakeValidIdentifier(element.QualifiedName.Name); - identifierName = getSymbol(identifierName, Constants.LocalElementConflictSuffix); + SymbolIdentifier symbolIdentifier = GetSymbol(identifierName, Constants.LocalElementConflictSuffix); + identifierName = symbolIdentifier; symbolToQName.Add(identifierName.ToUpper(CultureInfo.InvariantCulture), element.QualifiedName); qNameToSymbol.Add(element.QualifiedName, identifierName); return identifierName; @@ -315,7 +341,7 @@ public string AddLocalElement(XmlSchemaElement element) public string AddAttribute(XmlSchemaAttribute attribute) { string identifierName = NameGenerator.MakeValidIdentifier(attribute.QualifiedName.Name); - identifierName = getSymbol(identifierName, Constants.LocalAttributeConflictSuffix); + identifierName = getSymbol(identifierName, Constants.LocalAttributeConflictSuffix, out bool _); symbolToQName.Add(identifierName.ToUpper(CultureInfo.InvariantCulture), attribute.QualifiedName); return identifierName; } @@ -345,7 +371,7 @@ public List GetAnonymousTypes() foreach (AnonymousType at in anonymousTypes) { ClrTypeReference typeReference = at.typeRefence; - string typeIdentifier = getSymbol(at.identifier, at.typeRefence.LocalSuffix); + string typeIdentifier = getSymbol(at.identifier, at.typeRefence.LocalSuffix, out bool _); symbolToQName.Add(typeIdentifier.ToUpper(CultureInfo.InvariantCulture), XmlQualifiedName.Empty); typeReference.Name = typeIdentifier; at.identifier = typeIdentifier; @@ -368,18 +394,20 @@ public string AddMember(string identifierName) { // not making valid. Assuming this has already been done. string outputSymbol = null; - outputSymbol = getSymbol(identifierName, String.Empty); + outputSymbol = getSymbol(identifierName, String.Empty, out bool _); symbolToQName.Add(outputSymbol.ToUpper(CultureInfo.InvariantCulture), identifierName); return outputSymbol; } - private string getSymbol(string identifierName, string suffix) + private string getSymbol(string identifierName, string suffix, out bool didIncrementIdWithNumber) { + didIncrementIdWithNumber = false; + int id = 0; string symbol = identifierName; string symbolU = symbol.ToUpper(CultureInfo.InvariantCulture); - if (symbolToQName[symbolU] == null) + if (symbolToQName[symbolU] == null) { return symbol; } @@ -392,10 +420,37 @@ private string getSymbol(string identifierName, string suffix) { id++; symbolU = temp + id.ToString(CultureInfo.InvariantCulture.NumberFormat); + didIncrementIdWithNumber = true; } if (id > 0) symbol = symbol + id.ToString(CultureInfo.InvariantCulture.NumberFormat); + + return symbol; + } + + private SymbolIdentifier GetSymbol(string identifierName, string suffix) + { + int id = 0; + string symbol = identifierName; + string symbolU = symbol.ToUpper(CultureInfo.InvariantCulture); + if (symbolToQName[symbolU] == null) { + return symbol; + } + + symbol = symbol + suffix; + symbolU = symbol.ToUpper(CultureInfo.InvariantCulture); + string temp = symbolU; + + while (symbolToQName[symbolU] != null) { + id++; + symbolU = temp + id.ToString(CultureInfo.InvariantCulture.NumberFormat); + } + + if (id > 0) { + return new SymbolIdentifier(symbol, id); + } + return symbol; } } diff --git a/XObjectsCode/Src/PropertyBuilder.cs b/XObjectsCode/Src/PropertyBuilder.cs index 48e61e51..e428bbf3 100644 --- a/XObjectsCode/Src/PropertyBuilder.cs +++ b/XObjectsCode/Src/PropertyBuilder.cs @@ -108,9 +108,11 @@ public override void GenerateCode(ClrBasePropertyInfo property, List 0; } } - private CodeMemberProperty BuildLocalElementDictionary() + private CodeMemberProperty BuildLocalElementDictionaryCodeMemberProperty() { CodeMemberProperty localDictionaryProperty = CodeDomHelper.CreateInterfaceImplProperty( Constants.LocalElementsDictionary, Constants.IXMetaData, @@ -1213,8 +1216,12 @@ internal void AddTypeToTypeManager(CodeStatementCollection elementDictionaryStat ? "global::" + innerTypeName : "global::" + innerTypeNs + "." + innerTypeName; - wrapperDictionaryStatements.Add(CodeDomHelper.CreateMethodCallFromField(Constants.WrapperDictionaryField, - "Add", CodeDomHelper.Typeof(clrTypeInfo.clrFullTypeName), CodeDomHelper.Typeof(innerTypeFullName))); + CodeMethodInvokeExpression addDictionaryKvp = CodeDomHelper.CreateMethodCallFromField( + fieldName: Constants.WrapperDictionaryField, + methodName: "Add", + parameters: [CodeDomHelper.Typeof(clrTypeInfo.clrFullTypeName), CodeDomHelper.Typeof(innerTypeFullName)] + ); + wrapperDictionaryStatements.Add(addDictionaryKvp); } private CodeMethodInvokeExpression SetNameMethodCall() diff --git a/XObjectsCode/Src/TypesToCodeDom.cs b/XObjectsCode/Src/TypesToCodeDom.cs index 5bafa877..a3ccc0a4 100644 --- a/XObjectsCode/Src/TypesToCodeDom.cs +++ b/XObjectsCode/Src/TypesToCodeDom.cs @@ -1,4 +1,5 @@ //Copyright (c) Microsoft Corporation. All rights reserved. +#nullable enable using System; using System.Xml; @@ -643,8 +644,10 @@ private CodeTypeDeclaration GetCodeTypeDeclaration(string typeName, CodeNamespac return null; } - private void AddDefaultImports(CodeNamespace newCodeNamespace) + private void AddDefaultImports(CodeNamespace newCodeNamespace, string clrNamespace) { + if (clrNamespace == null) throw new ArgumentNullException(nameof(clrNamespace)); + newCodeNamespace.Imports.Add(new CodeNamespaceImport("System")); newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections")); newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Collections.Generic")); @@ -654,6 +657,7 @@ private void AddDefaultImports(CodeNamespace newCodeNamespace) newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Diagnostics")); newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Xml")); newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Xml.Schema")); + if (settings.EnableServiceReference) { newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Xml.Serialization")); @@ -661,6 +665,24 @@ private void AddDefaultImports(CodeNamespace newCodeNamespace) newCodeNamespace.Imports.Add(new CodeNamespaceImport("System.Xml.Linq")); newCodeNamespace.Imports.Add(new CodeNamespaceImport("Xml.Schema.Linq")); + + // at this point we need to check if adding global:: to any of the above namespace imports is necessary to avoid ambiguity with the + // generated code namespace. specifically what this fixes is that if the clrNamespace ends in a word that equals one of the starting + // words above (System or Xml), then compiler errors are more likely to occur due to ambiguity between the namespace import and the generated code namespace + List imports = newCodeNamespace.Imports.Cast().ToList(); + List firstNsComponentsFromImports = (from ns in imports.Select(i => i.Namespace) + let firstNsComponent = ns.Split(['.']).First() + select firstNsComponent).Distinct().ToList(); + string[] clrNamespaceComponents = clrNamespace.Split(['.']); + string last = clrNamespaceComponents.Last(); + + if (firstNsComponentsFromImports.Any(c => c.EndsWith(last))) { + List theImports = imports.FindAll(i => i.Namespace.StartsWith(last)); + + foreach (CodeNamespaceImport import in theImports) { + import.Namespace = "global::" + import.Namespace; + } + } } private TypeBuilder GetTypeBuilder() @@ -758,7 +780,7 @@ private CodeNamespace GetCodeNamespace(string clrNamespace) if (!codeNamespacesTable.TryGetValue(clrNamespace, out CodeNamespace currentCodeNamespace)) { currentCodeNamespace = new CodeNamespace(clrNamespace); - AddDefaultImports(currentCodeNamespace); + AddDefaultImports(currentCodeNamespace, clrNamespace); codeNamespacesTable.Add(clrNamespace, currentCodeNamespace); } diff --git a/XObjectsTests/CommandLineInterfaceTests.cs b/XObjectsTests/CommandLineInterfaceTests.cs index d2375f36..267fe9e6 100644 --- a/XObjectsTests/CommandLineInterfaceTests.cs +++ b/XObjectsTests/CommandLineInterfaceTests.cs @@ -1,6 +1,7 @@ using System; using System.IO; using System.Linq; +using System.Threading.Tasks; using NUnit.Framework; namespace Xml.Schema.Linq.Tests @@ -117,8 +118,10 @@ public void TestGenerateCodeFromSingleFileWithAutoConfig() /// Tests "linqtoxsd gen '(folder)' -a" /// [Test] - public void TestGenerateCodeFromSingleDirectoryWithAutoConfig() + public async Task TestGenerateCodeFromSingleDirectoryWithAutoConfig() { + await Task.Delay(TimeSpan.FromSeconds(2)); + _copyOfSchemasFolder.Refresh(); var microsoftBuildXsd = "Microsoft.Build.xsd"; var msBuildXsd = _copyOfSchemasFolder.GetFiles(microsoftBuildXsd, SearchOption.AllDirectories).Single(); @@ -137,6 +140,8 @@ public void TestGenerateCodeFromSingleDirectoryWithAutoConfig() Assert.IsTrue(generatedCsFile.Any()); var _ = generatedCsFile.Single(); + + await Task.Delay(TimeSpan.FromSeconds(2)); } ///