Пример #1
0
func main() {
	data, err := ioutil.ReadFile("xpath.xml")
	util.CheckErr(err)

	doc, err := xml.Parse(data, nil, nil, 0, xml.DefaultEncodingBytes)
	util.CheckErr(err)
	defer doc.Free()

	n, err := doc.Root().Search(`/probe/header/@vendor`)
	fmt.Println("Vendor:")
	fmt.Println(n)
	util.CheckErr(err)
}
Пример #2
0
func main() {

	data, err := ioutil.ReadFile("xpath.xml")
	if err != nil {
		log.Fatal(err)
	}

	doc, err := xml.Parse(data, nil, nil, 0, xml.DefaultEncodingBytes)
	if err != nil {
		log.Fatal(err)
	}
	defer doc.Free()

	xp := doc.DocXPathCtx()
	xp.RegisterNamespace("folia", "http://ilk.uvt.nl/folia")

	fmt.Println("\nAll sentences with all words:\n")

	xps := xpath.Compile("//folia:s")
	xpw := xpath.Compile("folia:w/folia:t")

	ss, err := doc.Root().Search(xps)
	if err != nil {
		log.Fatal(err)
	}
	for _, s := range ss {
		fmt.Println(s.Attr("id"))
		ww, err := s.Search(xpw)
		if err != nil {
			log.Fatal(err)
		}
		for _, w := range ww {
			fmt.Println("\t" + w.Parent().Attr("id") + "  \t" + w.Content())
		}
	}

	fmt.Println("\nSearch for specific sentence:\n")
	n, err := doc.Root().Search(`//folia:s[@xml:id="WR-P-E-E-0000000020.head.4.s.2"]`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(n)

	fmt.Println("\nSearch for sentence with specific word:\n")
	n, err = doc.Root().Search(`//folia:w[@xml:id="WR-P-E-E-0000000020.head.4.s.2.w.2"]`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(n[0].Parent())

}
Пример #3
0
// TODO: Make the Parser options configureable.
func (d *Decoder) Decode(data []byte, v interface{}) error {
	var opts = gokoxml.DefaultParseOption | gokoxml.XML_PARSE_NOENT
	doc, err := gokoxml.Parse(data, gokoxml.DefaultEncodingBytes, nil, opts, gokoxml.DefaultEncodingBytes)
	d.doc = doc
	if err != nil {
		return err
	}
	defer doc.Free()

	val := reflect.ValueOf(v)
	if val.Kind() != reflect.Ptr {
		return errors.New("non-pointer passed to Decode")
	}

	return d.unmarshal(val.Elem(), nil)
}
Пример #4
0
func (p *GokoParser) Decode(data []byte, result *ECSResponse) error {
	doc, err := gokoxml.Parse(data, gokoxml.DefaultEncodingBytes, nil, gokoxml.DefaultParseOption, gokoxml.DefaultEncodingBytes)
	p.doc = doc
	if err != nil {
		return err
	}
	defer p.doc.Free()

	doc.XPathCtx.RegisterNamespace("ecs", "http://webservices.amazon.com/AWSECommerceService/2010-11-01")

	root := doc.Root()

	res, err := root.Search("ecs:Items/ecs:Item")
	if err == nil && len(res) >= 1 {
		for _, v := range res {
			result.Items = append(result.Items, p.parseItem(v.FirstChild()))
		}
	}

	return err
}
Пример #5
0
func parse(c *cli.Context, data []byte) {
	doc, err := xml.Parse(data, nil, nil, 0, xml.DefaultEncodingBytes)
	util.CheckErr(err)
	defer doc.Free()

	xp := doc.DocXPathCtx()
	for _, xmlns := range c.StringSlice("xmlns") {
		ns := strings.SplitN(xmlns, ":", 2)
		if c.Bool("verbose") {
			fmt.Println("NS " + ns[0] + "==" + ns[1])
		}
		xp.RegisterNamespace(ns[0], ns[1])
	}

	xps := xpath.Compile(c.String("xpath"))
	s, err := doc.Root().Search(xps)
	util.CheckErr(err)
	for _, s := range s {
		util.CheckErr(err)
		fmt.Println(s.Content())
	}
}
Пример #6
0
/*
ParseXml parses an UTF-8 encoded byte array and returns an xml.XmlDocument. By default the parsing options ignore validation
and suppress errors and warnings. This allows one to liberal in accepting badly-formed documents, but is not standards-compliant.

If the content is not UTF-8 encoded or you want to customize the parsing options, you should call the Parse or ReadFile functions
found in the github.com/moovweb/gokogiri/xml package. The xml.StrictParsingOption is conveniently provided for standards-compliant
behaviour.
*/
func ParseXml(content []byte) (doc *xml.XmlDocument, err error) {
	return xml.Parse(content, xml.DefaultEncodingBytes, nil, xml.DefaultParseOption, xml.DefaultEncodingBytes)
}