package main import "github.com/netascode/xmldot" const xml = ` <catalog>  <book id="1">  <title>The Go Programming Language</title>  <author>Alan Donovan</author>  <price>44.99</price>  </book> </catalog>` func main() { title := xmldot.Get(xml, "catalog.book.title") println(title.String()) }

// Basic fluent chaining root := xmldot.Get(xml, "root") name := root.Get("user.name").String() age := root.Get("user.age").Int() // Deep chaining fullPath := xmldot.Get(xml, "root"). Get("company"). Get("department"). Get("team.member"). Get("name"). String() // Batch queries user := xmldot.Get(xml, "root.user") results := user.GetMany("name", "age", "email") name := results[0].String() age := results[1].Int() email := results[2].String() // Case-insensitive queries opts := &xmldot.Options{CaseSensitive: false} name := root.GetWithOptions("USER.NAME", opts).String() // Structure inspection with Map() user := xmldot.Get(xml, "root.user") m := user.Map() name := m["name"].String() age := m["age"].Int() // Iterate over all child elements for key, value := range m { fmt.Printf("%s = %s\n", key, value.String()) } // Map() with case-insensitive keys m := user.MapWithOptions(&xmldot.Options{CaseSensitive: false})

// Fast (recommended for hot paths) name := xmldot.Get(xml, "root.user.name") // Readable (recommended for business logic) user := xmldot.Get(xml, "root.user") name := user.Get("name")

items := xmldot.Get(xml, "catalog.items") // Extract all prices prices := items.Get("item.#.price") // Array of all prices

package main import "github.com/netascode/xmldot" const xml = ` <catalog>  <book id="1">  <title>The Go Programming Language</title>  <price>44.99</price>  </book> </catalog>` func main() { value, _ := xmldot.Set(xml, "catalog.book.price", 39.99) println(value) }

xml := `<root></root>` // Automatically creates <user> element with id attribute result, _ := xmldot.Set(xml, "root.user.@id", "123") // Result: <root><user id="123"></user></root> // Works with deep paths too result, _ = xmldot.Set(xml, "root.company.department.@name", "Engineering") // Result: <root><company><department name="Engineering"></department></company></root>

xml := `<catalog><book><title>Book 1</title></book></catalog>` // Append a new book using SetRaw for XML content result, _ := xmldot.SetRaw(xml, "catalog.book.-1", "<title>Book 2</title>") count := xmldot.Get(result, "catalog.book.#") // count.Int() → 2 // Works with empty arrays too xml2 := `<catalog></catalog>` result2, _ := xmldot.SetRaw(xml2, "catalog.book.-1", "<title>First Book</title>") // Result: <catalog><book><title>First Book</title></book></catalog>

xmldot.AddModifier("uppercase", func(xml, arg string) string { return strings.ToUpper(xml) }) result := xmldot.Get(xml, "catalog.book.title|@uppercase") // "THE GO PROGRAMMING LANGUAGE"

result := xmldot.Get(xml, "catalog.book.title") for _, title := range result.Array() { println(title.String()) }

xmldot.Get(xml, "catalog.book").ForEach(func(_, book xmldot.Result) bool { println(book.Get("title").String()) return true // keep iterating })

result.Type // String, Number, True, False, Null, or XML result.Str // the string value result.Num // the float64 number result.Raw // the raw xml result.Index // index in original xml result.String() string result.Bool() bool result.Int() int64 result.Float() float64 result.Array() []Result result.Exists() bool result.IsArray() bool result.Value() interface{} result.Get(path string) Result result.GetMany(paths ...string) []Result result.GetWithOptions(path string, opts *Options) Result result.ForEach(iterator func(index int, value Result) bool)

if !xmldot.Valid(xml) { return errors.New("invalid xml") } // Or get detailed errors if err := xmldot.ValidateWithError(xml); err != nil { fmt.Printf("Error at line %d, column %d: %s\n", err.Line, err.Column, err.Message) }

fragment := `<user id="1"><name>Alice</name></user> <user id="2"><name>Bob</name></user> <user id="3"><name>Carol</name></user>` // Validation accepts multiple roots if xmldot.Valid(fragment) { fmt.Println("Fragment is valid") } // Query first matching root name := xmldot.Get(fragment, "user.name") // → "Alice" // Array operations on matching roots count := xmldot.Get(fragment, "user.#") // → 3 first := xmldot.Get(fragment, "user.0.name") // → "Alice" names := xmldot.Get(fragment, "user.#.name") // → ["Alice", "Bob", "Carol"] // Modify first matching root result, _ := xmldot.Set(fragment, "user.@status", "active") // Build fragments incrementally using root-level append xml := `<user>Alice</user>` xml, _ = xmldot.Set(xml, "item.-1", "first") // Creates sibling: <user>Alice</user><item>first</item> xml, _ = xmldot.Set(xml, "item.-1", "second") // Appends sibling: <user>Alice</user><item>first</item><item>second</item>

results := xmldot.GetMany(xml, "catalog.book.0.title", "catalog.book.0.price") println(results[0].String()) // title println(results[1].Float()) // price

paths := []string{"catalog.book.0.price", "catalog.book.1.price"} values := []interface{}{39.99, 34.99} result, _ := xmldot.SetMany(xml, paths, values)

result, _ := xmldot.DeleteMany(xml, "catalog.book.0.tags", "catalog.book.1.tags")

var xml []byte = ... result := xmldot.GetBytes(xml, "catalog.book.title")

// Safe: concurrent reads var wg sync.WaitGroup for i := 0; i < 100; i++ { wg.Add(1) go func(id int) { defer wg.Done() result := xmldot.Get(xml, fmt.Sprintf("users.user.%d.name", id)) process(result) }(i) } wg.Wait()

var mu sync.Mutex currentXML := "<root></root>" func updateXML(path string, value interface{}) { mu.Lock() defer mu.Unlock() result, _ := xmldot.Set(currentXML, path, value) currentXML = result }