graphml

func ReadInto ¶

func ReadInto(r io.Reader) (*adjlist.AdjList[string, int64], int, error)

ReadInto parses a GraphML document from r into an adjacency list. Returns the loaded list, the number of edges added, and an error on parse failure.

func ReadIntoCappedCtx ¶ added in v0.2.0

func ReadIntoCappedCtx(ctx context.Context, r io.Reader, maxBytes int64) (*adjlist.AdjList[string, int64], int, error)

ReadIntoCappedCtx is ReadIntoCtx with an explicit input-size ceiling. When maxBytes > 0 the decoder fails with ErrInputTooLarge the moment consumption exceeds the limit, before the whole document is buffered; a value of zero or less disables the cap.

On any error the returned graph is nil (see ReadIntoCtx); the import is all-or-nothing at the in-memory level.

func ReadIntoCtx ¶

func ReadIntoCtx(ctx context.Context, r io.Reader) (*adjlist.AdjList[string, int64], int, error)

ReadIntoCtx is the context-aware variant of ReadInto. ctx.Err() is checked every 4096 edges. The input is capped at DefaultMaxBytes; use ReadIntoCappedCtx for an explicit ceiling.

On any error — a parse error, context cancellation, or the ErrInputTooLarge cap — the returned graph is nil; the import is all-or-nothing at the in-memory level, so a caller cannot accidentally commit a half-built graph. The typed error is returned unchanged; only the graph value is discarded.

func ReadWithProps ¶

func ReadWithProps(r io.Reader) (*lpg.Graph[string, int64], int, error)

ReadWithProps parses a GraphML document from r and returns an lpg.Graph with typed node properties derived from <key> declarations and <data> elements. Edge weights are read via the standard "weight" key. The second return value is the number of edges added.

func ReadWithPropsCappedCtx ¶ added in v0.2.0

func ReadWithPropsCappedCtx(ctx context.Context, r io.Reader, maxBytes int64) (*lpg.Graph[string, int64], int, error)

ReadWithPropsCappedCtx is ReadWithPropsCtx with an explicit input-size ceiling. When maxBytes > 0 the decoder fails with ErrInputTooLarge the moment consumption exceeds the limit, before the whole document is buffered; a value of zero or less disables the cap.

On any error the returned graph is nil (see ReadWithPropsCtx); the import is all-or-nothing at the in-memory level.

func ReadWithPropsCtx ¶

func ReadWithPropsCtx(ctx context.Context, r io.Reader) (*lpg.Graph[string, int64], int, error)

ReadWithPropsCtx is the context-aware variant of ReadWithProps. The input is capped at DefaultMaxBytes; use ReadWithPropsCappedCtx for an explicit ceiling.

On any error — a parse error, context cancellation, or the ErrInputTooLarge cap — the returned graph is nil; the import is all-or-nothing at the in-memory level, so a caller cannot accidentally commit a half-built graph. The typed error is returned unchanged; only the graph value is discarded.

func Write ¶

func Write(w io.Writer, a *adjlist.AdjList[string, int64]) error

Write streams a GraphML document representing a to w. The output includes a single <graph> with directed or undirected edgedefault inferred from a, a <key for=edge attr.name=weight attr.type=long> declaration, and one <node>/<edge> per node and edge.

package main

import (
	"bytes"
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph/adjlist"
	"github.com/FlavioCFOliveira/GoGraph/graph/io/graphml"
)

func main() {
	src := adjlist.New[string, int64](adjlist.Config{Directed: true})
	_ = src.AddEdge("a", "b", 7)
	_ = src.AddEdge("b", "c", 9)

	var buf bytes.Buffer
	if err := graphml.Write(&buf, src); err != nil {
		panic(err)
	}

	dst, edges, err := graphml.ReadInto(&buf)
	if err != nil {
		panic(err)
	}

	fmt.Println("edges read:", edges)
	fmt.Println("order:", dst.Order())
	fmt.Println("size:", dst.Size())
	fmt.Println("a->b:", dst.HasEdge("a", "b"))
}

Output:
edges read: 2
order: 3
size: 2
a->b: true

func WriteCtx ¶

func WriteCtx(ctx context.Context, w io.Writer, a *adjlist.AdjList[string, int64]) error

WriteCtx is the context-aware variant of Write. ctx.Err() is checked at the start of node and edge encoding; on cancellation returns the wrapped ctx.Err.

func WriteWithProps ¶

func WriteWithProps(w io.Writer, g *lpg.Graph[string, int64]) error

WriteWithProps writes a GraphML document to w for the LPG g. A <key> declaration is emitted for every property key encountered across all nodes, with attr.type set to the GraphML equivalent of the first value seen for that key. Properties are serialised as <data> child elements of their respective <node> elements. Edge weights are written with the standard id="w" key.

package main

import (
	"bytes"
	"fmt"

	"github.com/FlavioCFOliveira/GoGraph/graph/adjlist"
	"github.com/FlavioCFOliveira/GoGraph/graph/io/graphml"
	"github.com/FlavioCFOliveira/GoGraph/graph/lpg"
)

func main() {
	src := lpg.New[string, int64](adjlist.Config{Directed: true})
	_ = src.AddEdge("alice", "bob", 1)
	_ = src.SetNodeProperty("alice", "age", lpg.Int64Value(30))

	var buf bytes.Buffer
	if err := graphml.WriteWithProps(&buf, src); err != nil {
		panic(err)
	}

	dst, _, err := graphml.ReadWithProps(&buf)
	if err != nil {
		panic(err)
	}

	got, ok := dst.GetNodeProperty("alice", "age")
	age, _ := got.Int64()
	fmt.Println("alice has age:", ok)
	fmt.Println("alice.age:", age)
}

Output:
alice has age: true
alice.age: 30

func WriteWithPropsCtx ¶

func WriteWithPropsCtx(ctx context.Context, w io.Writer, g *lpg.Graph[string, int64]) error

WriteWithPropsCtx is the context-aware variant of WriteWithProps. ctx.Err() is checked before the node and edge encoding phases.