atom/source.go

package atom

import (
	"encoding/xml"
	"fmt"
)

type Source struct {
	XMLName xml.Name `xml:"source"`
	*CommonAttributes
	Authors      []*Person           `xml:"author,omitempty"`
	Categories   []*Category         `xml:",omitempty"`
	Contributors []*Person           `xml:"contributor,omitempty"`
	Generator    *Generator          `xml:",omitempty"`
	Icon         *Icon               `xml:",omitempty"`
	ID           *ID                 `xml:",omitempty"`
	Links        []*Link             `xml:",omitempty"`
	Logo         *Logo               `xml:",omitempty"`
	Rights       Text                `xml:"rights,omitempty"`
	Subtitle     Text                `xml:"subtitle,omitempty"`
	Title        Text                `xml:"title,omitempty"`
	Updated      *Date               `xml:"updated,omitempty"`
	Extensions   []*ExtensionElement `xml:",any,omitempty"`
}

// NewSource creates a new Source. It returns a *Source.
func NewSource() *Source {
	return &Source{CommonAttributes: newCommonAttributes()}
}

// AddAuthor adds the Person as an author to the Source.
func (s *Source) AddAuthor(p *Person) {
	if s.Authors == nil {
		s.Authors = make([]*Person, 1)
		s.Authors[0] = p
	} else {
		s.Authors = append(s.Authors, p)
	}
}

// DeleteAuthor deletes the Person from the Source. It return an error.
func (s *Source) DeleteAuthor(id int) error {
	length := len(s.Authors)
	if id > length {
		return fmt.Errorf("error deleting author from source %v: id %v out of range %v", s, id, length)
	}

	s.Authors = append(s.Authors[:id], s.Authors[id+1:]...)
	return nil
}

// AddCategory adds the Category to the Source.
func (s *Source) AddCategory(c *Category) {
	if s.Categories == nil {
		s.Categories = make([]*Category, 1)
		s.Categories[0] = c
	} else {
		s.Categories = append(s.Categories, c)
	}
}

// DeleteCategory deletes the Category from the Source. It return an error.
func (s *Source) DeleteCategory(id int) error {
	length := len(s.Categories)
	if id > length {
		return fmt.Errorf("error deleting category from source %v: id %v out of range %v", s, id, length)
	}

	s.Categories = append(s.Categories[:id], s.Categories[id+1:]...)
	return nil
}

// AddContributor adds the Person as a contributor to the Source.
func (s *Source) AddContributor(c *Person) {
	if s.Contributors == nil {
		s.Contributors = make([]*Person, 1)
		s.Contributors[0] = c
	} else {
		s.Contributors = append(s.Contributors, c)
	}
}

// DeleteContributor deletes the Person from the Source. It return an error.
func (s *Source) DeleteContributor(id int) error {
	length := len(s.Contributors)
	if id > length {
		return fmt.Errorf("error deleting contributor from source %v: id %v out of range %v", s, id, length)
	}

	s.Contributors = append(s.Contributors[:id], s.Contributors[id+1:]...)
	return nil
}

// AddLink adds the Link to the Source.
func (s *Source) AddLink(l *Link) {
	if s.Links == nil {
		s.Links = make([]*Link, 1)
		s.Links[0] = l
	} else {
		s.Links = append(s.Links, l)
	}
}

// DeleteLink deletes the Link from the Source. It return an error.
func (s *Source) DeleteLink(id int) error {
	length := len(s.Links)
	if id > length {
		return fmt.Errorf("error deleting link from source %v: id %v out of range %v", s, id, length)
	}

	s.Links = append(s.Links[:id], s.Links[id+1:]...)
	return nil
}

// AddExtension adds the ExtensionElement to the Source.
func (s *Source) AddExtension(e *ExtensionElement) {
	if s.Extensions == nil {
		s.Extensions = make([]*ExtensionElement, 1)
		s.Extensions[0] = e
	} else {
		s.Extensions = append(s.Extensions, e)
	}
}

// DeleteExtension deletes the Extension from the Source. It return an error.
func (s *Source) DeleteExtension(id int) error {
	length := len(s.Extensions)
	if id > length {
		return fmt.Errorf("error deleting extension from source %v: id %v out of range %v", s, id, length)
	}

	s.Extensions = append(s.Extensions[:id], s.Extensions[id+1:]...)
	return nil
}

// Check checks the Source for incompatibilities with RFC4287. It returns an
// error.
func (s *Source) Check() error {
	for i, a := range s.Authors {
		if err := a.Check(); err != nil {
			return fmt.Errorf("author element %v of source %v: %v", i, s, err)
		}
	}

	for i, c := range s.Categories {
		if err := c.Check(); err != nil {
			return fmt.Errorf("category element %v of source %v: %v", i, s, err)
		}
	}

	for i, c := range s.Contributors {
		if err := c.Check(); err != nil {
			return fmt.Errorf("contributor element %v of source %v: %v", i, s, err)
		}
	}

	if s.Generator != nil {
		if err := s.Generator.Check(); err != nil {
			return fmt.Errorf("generator element of source %v: %v", s, err)
		}
	}

	if s.Icon != nil {
		if err := s.Icon.Check(); err != nil {
			return fmt.Errorf("icon element of source %v: %v", s, err)
		}
	}

	if s.ID != nil {
		if err := s.ID.Check(); err != nil {
			return fmt.Errorf("id element of source %v: %v", s, err)
		}
	}

	for i, l := range s.Links {
		if err := l.Check(); err != nil {
			return fmt.Errorf("link element %v of source %v: %v", i, s, err)
		}
	}

	if s.Logo != nil {
		if err := s.Logo.Check(); err != nil {
			return fmt.Errorf("logo element of source %v: %v", s, err)
		}
	}

	if s.Rights != nil {
		if err := s.Rights.Check(); err != nil {
			return fmt.Errorf("rights element of source %v: %v", s, err)
		}
	}

	if s.Subtitle != nil {
		if err := s.Subtitle.Check(); err != nil {
			return fmt.Errorf("subtitle element of source %v: %v", s, err)
		}
	}

	if s.Title != nil {
		if err := s.Title.Check(); err != nil {
			return fmt.Errorf("title element of source %v: %v", s, err)
		}
	}

	if s.Updated != nil {
		if err := s.Updated.Check(); err != nil {
			return fmt.Errorf("updated element of source %v: %v", s, err)
		}
	}

	for i, e := range s.Extensions {
		if err := e.Check(); err != nil {
			return fmt.Errorf("extension element %v of source %v: %v", i, s, err)
		}
	}

	return nil
}