xsd

Documentation

Index

• type All
• type Alternative
• type Annotation
• type AnyAttribute
• type Assert
• type Attribute
• type AttributeGroup
• type Choice
• type ComplexContent
• type ComplexType
  • func (t ComplexType) GetAttributes() []Attribute
• type Element
• type Group
• type Import
• type Include
• type Key
• type Keyref
• type ListOfQName
• type NCName
• type NestedParticle
• type Notation
• type Override
• type Pattern
• type QName
• type Redefine
• type Schema
  • func (s *Schema) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
• type Sequence
  • func (s *Sequence) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error
• type SimpleContent
• type SimpleType
• type TypeDefParticleGroup
• type Unique
• type XMLAppInfo
• type XMLDefaultOpenContent
• type XMLDocumentation
• type XMLEnumeration
• type XMLExplicitTimezone
• type XMLFractionDigits
• type XMLLength
• type XMLLocalSimpleType
• type XMLMaxExclusive
• type XMLMaxInclusive
• type XMLMaxLength
• type XMLMinExclusive
• type XMLMinInclusive
• type XMLMinLength
• type XMLSimpleRestrictionModel
• type XMLTopLevelSimpleType
• type XMLTotalDigits
• type XMLWhiteSpace

Types

type All

type All struct {
}

type Alternative

type Alternative struct {
	Id                    string `xml:"id,attr"`
	Test                  string `xml:"test,attr"`
	Type                  string `xml:"type,attr"`
	XpathDefaultNamespace string `xml:"xpathDefaultNamespace"`

	Annotation  *Annotation  `xml:"annotation"`
	SimpleType  *SimpleType  `xml:"simpleType"`
	ComplexType *ComplexType `xml:"complexType"`
	Unique      []Unique     `xml:"unique"`
	Key         []Key        `xml:"key"`
	Keyref      []Keyref     `xml:"keyref"`
}

type Annotation

type Annotation struct {
	Id string `xml:"id,attr"`

	AppInfo       *XMLAppInfo       `xml:"appinfo"`
	Documentation *XMLDocumentation `xml:"documentation"`
}

type AnyAttribute

type AnyAttribute struct {
	Id               string `xml:"id,attr"`
	Namespace        string `xml:"namespace,attr"`
	NotNamespace     string `xml:"notNamespace,attr"`
	NotQName         string `xml:"notQName,attr"`
	ProcessConttents string `xml:"processContents,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type Assert

type Assert struct {
	Id                    string `xml:"id,attr"`
	Test                  string `xml:"test,attr"`
	XPathDefaultNamespace string `xml:"xpathDefaultNamespace,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type Attribute

type Attribute struct {
	Default         *string `xml:"default,attr"`
	Fixed           *string `xml:"fixed,attr"`
	Form            string  `xml:"form,attr"`
	Id              string  `xml:"id,attr"`
	Name            string  `xml:"name,attr"`
	Ref             QName   `xml:"ref,attr"`
	TargetNamespace anyURI  `xml:"targetNamespace,attr"`
	Type            QName   `xml:"type,attr"`
	Use             string  `xml:"use,attr"`
	Inheritable     *bool   `xml:"inheritable,attr"`

	Annotation *Annotation `xml:"annotation"`
	SimpleType *SimpleType `xml:"simpleType"`
}

type AttributeGroup

type AttributeGroup struct {
}

type Choice

type Choice struct {
	// contains filtered or unexported fields
}

type ComplexContent

type ComplexContent struct {
	Id    string `xml:"id,attr"`
	Mixed *bool  `xml:"mixed,attr"`

	Annotation  *Annotation `xml:"annotation"`
	Restriction *struct {
		Base string `xml:"base,attr"`
		Id   string `xml:"id,attr"`

		Annotation      *Annotation      `xml:"annotation"`
		Group           *Group           `xml:"group"`
		Attributes      []Attribute      `xml:"attribute"`
		AttributeGroups []AttributeGroup `xml:"attributeGroup"`
		Assert          *Assert          `xml:"assert"`

		TypeDefParticleGroup
	} `xml:"restriction"`
	Extension *struct {
		Base string `xml:"base,attr"`
		Id   string `xml:"id,attr"`

		Annotation      *Annotation      `xml:"annotation"`
		Group           *Group           `xml:"group"`
		Attributes      []Attribute      `xml:"attribute"`
		AttributeGroups []AttributeGroup `xml:"attributeGroup"`
		Assert          *Assert          `xml:"assert"`

		TypeDefParticleGroup
	} `xml:"extension"`
}

type ComplexType

type ComplexType struct {
	Abstract               bool   `xml:"abstract,attr"`
	Block                  string `xml:"block,attr"`
	Final                  string `xml:"final,attr"`
	Id                     string `xml:"id,attr"`
	Mixed                  *bool  `xml:"mixed,attr"`
	Name                   string `xml:"name,attr"`
	DefaultAttributesApply bool   `xml:"defaultAttributesApply,attr"`

	Annotation      *Annotation      `xml:"annotation"`
	SimpleContent   *SimpleContent   `xml:"simpleContent"`
	ComplexContent  *ComplexContent  `xml:"complexContent"`
	Group           *Group           `xml:"group"`
	Attributes      []Attribute      `xml:"attribute"`
	AttributeGroups []AttributeGroup `xml:"attributeGroup"`
	Assert          *Assert          `xml:"assert"`

	TypeDefParticleGroup
}

func (ComplexType) GetAttributes

func (t ComplexType) GetAttributes() []Attribute

type Element

type Element struct {
	Abstract bool `xml:"abstract,attr"`
	// (#all | List of (extension | restriction | substitution))
	Block             string  `xml:"block,attr"`
	Default           string  `xml:"default,attr"`
	Final             string  `xml:"final,attr"`
	Fixed             string  `xml:"fixed,attr"`
	Form              string  `xml:"form,attr"`
	Id                string  `xml:"id,attr"`
	MaxOccurs         *string `xml:"maxOccurs,attr"`
	MinOccurs         *int    `xml:"minOccurs,attr"`
	Name              string  `xml:"name,attr"`
	Nillable          bool    `xml:"nillable,attr"`
	Ref               string  `xml:"ref,attr"`
	SubstitutionGroup string  `xml:"substitutionGroup"`
	TargetNamespace   string  `xml:"targetNamespace,attr"`
	Type              QName   `xml:"type,attr"`

	Annotation  *Annotation  `xml:"annotation"`
	SimpleType  *SimpleType  `xml:"simpleType"`
	ComplexType *ComplexType `xml:"complexType"`
	Alternative *Alternative `xml:"alternative"`
	// contains filtered or unexported fields
}

type Group

type Group struct {
	// contains filtered or unexported fields
}

type Import

type Import struct {
	// Annotated
	Annotation *Annotation `xml:"annotation"`
	Id         string      `xml:"id,attr"`

	Namespace      anyURI `xml:"namespace,attr"`
	SchemaLocation anyURI `xml:"schemaLocation,attr"`
}

type Include

type Include struct {
}

type Key

type Key struct {
	Name string `xml:"name,attr"`
	Ref  string `xml:"ref,attr"`
}

type Keyref

type Keyref struct {
	Name  string `xml:"name,attr"`
	Ref   string `xml:"ref,attr"`
	Refer string `xml:"refer,attr"`
}

type ListOfQName

type ListOfQName []QName

A list of QName

type NCName

type NCName string

NCName represents XML "non-colonized" Names. white-space: collapse

type NestedParticle

type NestedParticle interface {
	// contains filtered or unexported methods
}

type Notation

type Notation struct {
}

type Override

type Override struct {
}

type Pattern

type Pattern struct {
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type QName

type QName = string

QName represents XML qualified names.

type Redefine

type Redefine struct {
}

type Schema

type Schema struct {
	XMLAttrs []xml.Attr `xml:"-"`

	AttributeFormDefault  string `xml:"attributeFormDefault,attr"`
	BlockDefault          string `xml:"blockDefault,attr"`
	DefaultAttributes     string `xml:"defaultAttributes,attr"`
	XpathDefaultNamespace string `xml:"xpathDefaultNamespace,attr"`
	ElementFormDefault    string `xml:"elementFormDefault,attr"`
	FinalDefault          string `xml:"finalDefault,attr"`
	Id                    string `xml:"id,attr"`
	TargetNamespace       string `xml:"targetNamespace,attr"`
	Version               string `xml:"version,attr"`

	Composition        []interface{}
	DefaultOpenContent *XMLDefaultOpenContent `xml:"defaultOpenContent"`
	Annotation         []Annotation           `xml:"annotation"`
	SchemaTop          []interface{}
}

func (*Schema) UnmarshalXML

func (s *Schema) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type Sequence

type Sequence struct {
	XMLAttrs []xml.Attr `xml:"-"`

	Id        string `xml:"id,attr"`
	MaxOccurs int    `xml:"maxOccurs,attr"`
	MinOccurs int    `xml:"minOccurs,attr"`

	Annotation *Annotation `xml:"annotation"`
	Content    []NestedParticle
	// contains filtered or unexported fields
}

func (*Sequence) UnmarshalXML

func (s *Sequence) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error

type SimpleContent

type SimpleContent struct {
	Id string `xml:"id,attr"`

	Annotation  *Annotation `xml:"annotation"`
	Restriction *struct {
		Base QName  `xml:"base,attr"`
		Id   string `xml:"id,attr"`

		Annotation      *Annotation      `xml:"annotation"`
		SimpleType      *SimpleType      `xml:"simpleType"`
		FacetOrAny      []interface{}    `xml:"-"`
		Choice          *Choice          `xml:"choice"`
		Sequence        *Sequence        `xml:"sequence"`
		Attributes      []Attribute      `xml:"attribute"`
		AttributeGroups []AttributeGroup `xml:"attributeGroup"`
		AnyAtttribute   *AnyAttribute    `xml:"anyAttribute"`
		Assert          *Assert          `xml:"assert"`
	} `xml:"restriction"`
	Extension *struct {
		Base string `xml:"base,attr"`
		Id   string `xml:"id,attr"`

		Annotation      *Annotation      `xml:"annotation"`
		Attributes      []Attribute      `xml:"attribute"`
		AttributeGroups []AttributeGroup `xml:"attributeGroup"`
		AnyAtttribute   *AnyAttribute    `xml:"anyAttribute"`
		Assert          *Assert          `xml:"assert"`
	} `xml:"extension"`
}

type SimpleType

type SimpleType struct {
	Id string `xml:"id,attr"`

	Restriction *struct {
		Base QName  `xml:"base,attr"`
		Id   string `xml:"id,attr"`

		Annotation *Annotation `xml:"annotation"`
	} `xml:"restriction"`
	List *struct {
		Id       string `xml:"id,attr"`
		ItemType QName  `xml:"itemType,attr"`

		Annotation *Annotation `xml:"annotation"`
		SimpleType *SimpleType `xml:"simpleType"`
	} `xml:"list"`
	Union *struct {
		Id          string      `xml:"id,attr"`
		MemberTypes ListOfQName `xml:"memberTypes,attr"`

		Annotation  *Annotation   `xml:"annotation"`
		SimpleTypes []*SimpleType `xml:"simpleType"`
	} `xml:"union"`
}

type TypeDefParticleGroup

type TypeDefParticleGroup struct {
	All      *All      `xml:"all"`
	Choice   *Choice   `xml:"choice"`
	Sequence *Sequence `xml:"sequence"`
}

type Unique

type Unique struct {
	Name string `xml:"name,attr"`
	Ref  string `xml:"ref,attr"`
}

type XMLAppInfo

type XMLAppInfo struct {
	Source  anyURI `xml:"source,attr"`
	Content string `xml:",chardata"`
}

type XMLDefaultOpenContent

type XMLDefaultOpenContent struct {
}

type XMLDocumentation

type XMLDocumentation struct {
	Source  anyURI `xml:"source,attr"`
	Content string `xml:",chardata"`
}

type XMLEnumeration

type XMLEnumeration struct {
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLExplicitTimezone

type XMLExplicitTimezone struct {
	Fixed string `xml:"fixed,attr"`
	Value NCName `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLFractionDigits

type XMLFractionDigits struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value int    `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLLength

type XMLLength struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value int    `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLLocalSimpleType

type XMLLocalSimpleType struct {
	SimpleType
}

type XMLMaxExclusive

type XMLMaxExclusive struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLMaxInclusive

type XMLMaxInclusive struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLMaxLength

type XMLMaxLength struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value int    `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLMinExclusive

type XMLMinExclusive struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLMinInclusive

type XMLMinInclusive struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLMinLength

type XMLMinLength struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value int    `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLSimpleRestrictionModel

type XMLSimpleRestrictionModel struct {
	// Annotated
	Annotation *Annotation `xml:"annotation"`
	Id         string      `xml:"id,attr"`

	SimpleType *XMLLocalSimpleType `xml:"simpleType"`

	MinExclusive     []XMLMinExclusive     `xml:"minExclusive"`
	MinInclusive     []XMLMinInclusive     `xml:"minInclusive"`
	MaxExclusive     []XMLMaxExclusive     `xml:"maxExclusive"`
	MaxInclusive     []XMLMaxInclusive     `xml:"maxInclusive"`
	TotalDigits      []XMLTotalDigits      `xml:"totalDigits"`
	FractionDigits   []XMLFractionDigits   `xml:"fractionDigits"`
	Length           []XMLLength           `xml:"length"`
	MinLength        []XMLMinLength        `xml:"minLength"`
	MaxLength        []XMLMaxLength        `xml:"maxLength"`
	Enumeration      []XMLEnumeration      `xml:"enumeration"`
	WhiteSpace       []XMLWhiteSpace       `xml:"whiteSpace"`
	Pattern          []Pattern             `xml:"pattern"`
	Assertion        []Assert              `xml:"assertion"`
	ExplicitTimezone []XMLExplicitTimezone `xml:"explicitTimezone"`
}

type XMLTopLevelSimpleType

type XMLTopLevelSimpleType struct {
	SimpleType
	Final string `xml:"final,attr"`
	Name  NCName `xml:"name,attr"`
}

type XMLTotalDigits

type XMLTotalDigits struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	Value int    `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}

type XMLWhiteSpace

type XMLWhiteSpace struct {
	Fixed string `xml:"fixed,attr"`
	Id    string `xml:"id,attr"`
	// (collapse | preserve | replace)
	Value string `xml:"value,attr"`

	Annotation *Annotation `xml:"annotation"`
}