func (t *TextConstruct) ProcessStartElement(el xmlutils.StartElement) (xmlutils.Visitor, xmlutils.ParserError) {
t.name = el.Name.Local
t.Extension = extension.InitExtension(t.name, t.Extension.Manager)
t.reset()
for _, attr := range el.Attr {
switch attr.Name.Space {
case xmlutils.XML_NS:
t.ProcessAttr(attr)
case "":
if attr.Name.Local == "type" {
t.Type = attr.Value
break
}
default:
t.Extension.ProcessAttr(attr, t)
}
}
switch t.Type {
case "text", "html":
t.PlainText.Parent = t
return t.PlainText, nil
case "xhtml":
t.XHTML.Parent = t
return t.XHTML, nil
}
return t.PlainText, nil
}
func NewChannelExt(manager extension.Manager) *Channel {
c := Channel{
Title: NewBasicElementExt(manager),
Link: NewBasicElementExt(manager),
Description: NewUnescapedContentExt(manager),
Language: NewBasicElementExt(manager),
Copyright: NewBasicElementExt(manager),
ManagingEditor: NewBasicElementExt(manager),
Webmaster: NewBasicElementExt(manager),
PubDate: NewDateExt(manager),
LastBuildDate: NewDateExt(manager),
Generator: NewBasicElementExt(manager),
Docs: NewBasicElementExt(manager),
Cloud: NewCloudExt(manager),
Ttl: NewBasicElementExt(manager),
Image: NewImageExt(manager),
Rating: NewBasicElementExt(manager),
SkipHours: NewBasicElementExt(manager),
SkipDays: NewBasicElementExt(manager),
depth: xmlutils.NewDepthWatcher(),
}
c.init()
c.Extension = extension.InitExtension("channel", manager)
return &c
}
func NewCloudExt(manager extension.Manager) *Cloud {
c := NewCloud()
c.Extension = extension.InitExtension("cloud", manager)
return c
}
func NewBasicElementExt(manager extension.Manager) *BasicElement {
b := NewBasicElement()
b.Extension = extension.InitExtension("basicelement", manager)
return b
}
func NewIdExt(manager extension.Manager) *Id {
i := NewId()
i.Extension = extension.InitExtension("id", manager)
return i
}
func NewDateExt(manager extension.Manager) *Date {
d := NewDate()
d.Extension = extension.InitExtension("date", manager)
return d
}
func NewDateExt(manager extension.Manager) *Date {
d := NewDate()
d.depth.SetMaxDepth(1)
d.Extension = extension.InitExtension("date", manager)
return d
}
func NewBasicElementExt(parent xmlutils.Visitor, manager extension.Manager) *BasicElement {
b := NewBasicElement(parent)
b.Extension = extension.InitExtension("basicelement", manager)
return b
}
func newWrapperExt(manager extension.Manager) *wrapper {
w := newWrapper()
w.Extensions = extension.InitExtension("__", manager)
return w
}
func NewPersonExt(manager extension.Manager) *Person {
p := Person{depth: xmlutils.NewDepthWatcher()}
p.Name = NewBasicElementExt(&p, manager)
p.Uri = NewBasicElementExt(&p, manager)
p.Email = NewBasicElementExt(&p, manager)
p.Extension = extension.InitExtension("person", manager)
p.init()
return &p
}
func NewImageExt(manager extension.Manager) *Image {
i := Image{depth: xmlutils.NewDepthWatcher()}
i.Url = NewBasicElementExt(manager)
i.Title = NewBasicElementExt(manager)
i.Link = NewBasicElementExt(manager)
i.Width = NewBasicElementExt(manager)
i.Height = NewBasicElementExt(manager)
i.Description = NewBasicElementExt(manager)
i.init()
i.Extension = extension.InitExtension("image", manager)
return &i
}
func (b *BasicElement) ProcessStartElement(el xmlutils.StartElement) (xmlutils.Visitor, xmlutils.ParserError) {
if b.depth.IsRoot() {
b.name = el.Name
b.Extension = extension.InitExtension(b.name.Local, b.Extension.Manager)
for _, attr := range el.Attr {
b.Extension.ProcessAttr(attr, b)
}
}
if b.depth.Down() == xmlutils.MaxDepthReached {
return b, xmlutils.NewError(LeafElementHasChild, fmt.Sprintf("'%s' shoud not have childs", b.Name))
}
return b, nil
}
func NewSourceExt(manager extension.Manager) *Source {
s := Source{
Generator: NewGeneratorExt(manager),
Icon: NewIconExt(manager),
Id: NewIdExt(manager),
Logo: NewLogoExt(manager),
Rights: NewTextConstructExt(manager),
Subtitle: NewTextConstructExt(manager),
Title: NewTextConstructExt(manager),
Updated: NewDateExt(manager),
depth: xmlutils.NewDepthWatcher(),
}
s.init()
s.Extension = extension.InitExtension("source", manager)
return &s
}
func NewFeedExt(manager extension.Manager) *Feed {
f := Feed{
Generator: NewGeneratorExt(manager),
Icon: NewIconExt(manager),
Id: NewIdExt(manager),
Logo: NewLogoExt(manager),
Rights: NewTextConstructExt(manager),
Subtitle: NewTextConstructExt(manager),
Title: NewTextConstructExt(manager),
Updated: NewDateExt(manager),
depth: xmlutils.NewDepthWatcher(),
}
f.init()
f.Extension = extension.InitExtension("feed", manager)
return &f
}
func NewEntryExt(manager extension.Manager) *Entry {
e := Entry{
Content: NewContentExt(manager),
Id: NewIdExt(manager),
Published: NewDateExt(manager),
Rights: NewTextConstructExt(manager),
Source: NewSourceExt(manager),
Summary: NewTextConstructExt(manager),
Title: NewTextConstructExt(manager),
Updated: NewDateExt(manager),
depth: xmlutils.NewDepthWatcher(),
}
e.init()
e.Extension = extension.InitExtension("entry", manager)
return &e
}
func NewItemExt(manager extension.Manager) *Item {
i := Item{
Title: NewBasicElementExt(manager),
Link: NewBasicElementExt(manager),
Description: NewUnescapedContentExt(manager),
Author: NewBasicElementExt(manager),
Comments: NewBasicElementExt(manager),
Enclosure: NewEnclosureExt(manager),
Guid: NewGuidExt(manager),
PubDate: NewDateExt(manager),
Source: NewSourceExt(manager),
depth: xmlutils.NewDepthWatcher(),
}
i.init()
i.Extension = extension.InitExtension("item", manager)
return &i
}
func (u *UnescapedContent) ProcessStartElement(el xmlutils.StartElement) (xmlutils.Visitor, xmlutils.ParserError) {
if u.depth.IsRoot() {
u.name = el.Name
u.Extension = extension.InitExtension(u.name.Local, u.Extension.Manager)
for _, attr := range el.Attr {
u.Extension.ProcessAttr(attr, u)
}
}
err := utils.NewErrorAggregator()
u.depth.Down()
if error := u.EncodeXHTMLToken(el); error != nil {
err.NewError(xmlutils.NewError(XHTMLEncodeToStringError, "cannot encode XHTML"))
}
return u, err.ErrorObject()
}
func (p *Person) ProcessStartElement(el xmlutils.StartElement) (xmlutils.Visitor, xmlutils.ParserError) {
if p.depth.IsRoot() {
p.reset()
p.name = el.Name.Local
p.Extension = extension.InitExtension(p.name, p.Extension.Manager)
for _, attr := range el.Attr {
if !p.ProcessAttr(attr) {
p.Extension.ProcessAttr(attr, p)
}
}
}
switch el.Name.Space {
case "", "http://www.w3.org/2005/atom":
switch el.Name.Local {
case "name":
p.Name.Content.IncOccurence()
p.Name.Reset()
return p.Name.ProcessStartElement(el)
case "uri":
p.Uri.Content.IncOccurence()
p.Uri.Reset()
return p.Uri.ProcessStartElement(el)
case "email":
p.Email.Content.IncOccurence()
p.Email.Reset()
return p.Email.ProcessStartElement(el)
}
default:
return p.Extension.ProcessElement(el, p)
}
p.depth.Down()
return p, nil
}
func NewEnclosureExt(manager extension.Manager) *Enclosure {
e := NewEnclosure()
e.Extension = extension.InitExtension("enclosure", manager)
return e
}
func NewSourceExt(manager extension.Manager) *Source {
s := NewSource()
s.Extension = extension.InitExtension("source", manager)
return s
}
func NewTextConstructExt(manager extension.Manager) *TextConstruct {
t := NewTextConstruct()
t.Extension = extension.InitExtension("textconstruct", manager)
return t
}
func NewCategoryExt(manager extension.Manager) *Category {
c := NewCategory()
c.Extension = extension.InitExtension("category", manager)
return c
}
func NewGuidExt(manager extension.Manager) *Guid {
g := NewGuid()
g.Extension = extension.InitExtension("guid", manager)
return g
}
func NewLinkExt(manager extension.Manager) *Link {
l := NewLink()
l.Extension = extension.InitExtension("link", manager)
return l
}
func NewGeneratorExt(manager extension.Manager) *Generator {
g := NewGenerator()
g.Extension = extension.InitExtension("generator", manager)
return g
}
func NewLogoExt(manager extension.Manager) *Logo {
l := NewLogo()
l.Extension = extension.InitExtension("logo", manager)
return l
}
func NewIconExt(manager extension.Manager) *Icon {
i := NewIcon()
i.Extension = extension.InitExtension("icon", manager)
return i
}
func NewContentExt(manager extension.Manager) *Content {
c := NewContent()
c.Extension = extension.InitExtension("content", manager)
return c
}
func NewUnescapedContentExt(manager extension.Manager) *UnescapedContent {
u := NewUnescapedContent()
u.Extension = extension.InitExtension("unescaped", manager)
return u
}
