grf

Documentation

Index

• Variables
• func Delete(g *Graph, id ID) error
• func DeleteEdge(g *Graph, from ID, et EdgeType, to ...ID) error
• func DeleteMapped(g *Graph, nt NodeType, key ...string) error
• func LookupEdgeInfo(g *Graph, from ID, et ...EdgeType) (map[EdgeType]EdgeInfo, error)
• func SetEdge(g *Graph, e ...Edge[any]) error
• type Edge
  • func EdgeRange[T any](g *Graph, from ID, et EdgeType, offset, limit int) ([]Edge[T], error)
  • func LookupEdge[T any](g *Graph, from ID, et EdgeType, to ID) (*Edge[T], error)
  • func (e Edge[T]) String() string
• type EdgeData
• type EdgeInfo
• type EdgeInfoData
• type EdgeType
• type EdgeTypeID
• type EdgeTypeInfo
• type Graph
  • func New(m Mapper, s ...Store) *Graph
  • func (g *Graph) Register(ti ...TypeInfo)
• type ID
• type LocalID
• type Mapper
• type Node
  • func Add[T any](g *Graph, nt NodeType, v T) (*Node[T], error)
  • func Lookup[T any](g *Graph, id ID) (*Node[T], error)
  • func Mapped[T any](g *Graph, nt NodeType, key string) (*Node[T], error)
  • func SetMapped[T any](g *Graph, nt NodeType, key string, fn func(T) (T, error)) (*Node[T], error)
  • func Update[T any](g *Graph, id ID, fn func(T) (T, error)) (*Node[T], error)
  • func (n Node[T]) String() string
• type NodeData
• type NodeType
• type Store
• type TypeInfo

Variables

var (
	ErrNotFound        = errors.New("not found")
	ErrVersionMismatch = errors.New("version mismatch")
	ErrInvalidType     = errors.New("invalid type")
	ErrInvalidEdgeType = errors.New("invalid edge type")
)

Functions

func Delete

func Delete(g *Graph, id ID) error

func DeleteEdge

func DeleteEdge(g *Graph, from ID, et EdgeType, to ...ID) error

func DeleteMapped

func DeleteMapped(g *Graph, nt NodeType, key ...string) error

func LookupEdgeInfo

func LookupEdgeInfo(g *Graph, from ID, et ...EdgeType) (map[EdgeType]EdgeInfo, error)

func SetEdge

func SetEdge(g *Graph, e ...Edge[any]) error

Types

type Edge

type Edge[T any] struct {
	From     ID
	Type     EdgeType
	To       ID
	Sequence int64
	Data     T
}

func EdgeRange

func EdgeRange[T any](g *Graph, from ID, et EdgeType, offset, limit int) ([]Edge[T], error)

func LookupEdge

func LookupEdge[T any](g *Graph, from ID, et EdgeType, to ID) (*Edge[T], error)

func (Edge[T]) String

func (e Edge[T]) String() string

type EdgeData

type EdgeData struct {
	From     LocalID
	TypeID   EdgeTypeID
	To       ID
	Sequence int64
	Data     []byte
}

type EdgeInfo

type EdgeInfo struct {
	Count   int
	Version int64
}

type EdgeInfoData

type EdgeInfoData struct {
	TypeID EdgeTypeID
	EdgeInfo
}

type EdgeType

type EdgeType string

type EdgeTypeID

type EdgeTypeID int32

type EdgeTypeInfo

type EdgeTypeInfo struct {
	Type EdgeType
}

type Graph

type Graph struct {
	// contains filtered or unexported fields
}

func New

func New(m Mapper, s ...Store) *Graph

func (*Graph) Register

func (g *Graph) Register(ti ...TypeInfo)

type ID

type ID int64

type LocalID

type LocalID int32

type Mapper

type Mapper interface {
	Map(nt NodeType, key string) (ID, error)

	SetMapping(nt NodeType, key string, id ID) error
	DeleteMapping(nt NodeType, key ...string) error
}

type Node

type Node[T any] struct {
	ID      ID
	Type    NodeType
	Data    T
	Version int64
}

func Add

func Add[T any](g *Graph, nt NodeType, v T) (*Node[T], error)

func Lookup

func Lookup[T any](g *Graph, id ID) (*Node[T], error)

func Mapped

func Mapped[T any](g *Graph, nt NodeType, key string) (*Node[T], error)

func SetMapped

func SetMapped[T any](
	g *Graph, nt NodeType, key string, fn func(T) (T, error),
) (*Node[T], error)

func Update

func Update[T any](g *Graph, id ID, fn func(T) (T, error)) (*Node[T], error)

func (Node[T]) String

func (n Node[T]) String() string

type NodeData

type NodeData struct {
	ID      LocalID
	Data    []byte
	Version int64
}

type NodeType

type NodeType string

type Store

type Store interface {
	Node(nt NodeType, id ...LocalID) ([]NodeData, error)
	NodeRange(nt NodeType, after LocalID, limit int) ([]NodeData, error)

	Edge(nt NodeType, from LocalID, et EdgeTypeID, to ...ID) ([]EdgeData, error)
	EdgeInfo(nt NodeType, from LocalID, et ...EdgeTypeID) ([]EdgeInfoData, error)
	EdgeRange(nt NodeType, from LocalID, et EdgeTypeID, offset, limit int) ([]EdgeData, error)

	AddNode(nt NodeType, data []byte) (LocalID, int64, error)
	UpdateNode(nt NodeType, id LocalID, data []byte, currentVersion int64) error
	DeleteNode(nt NodeType, id ...LocalID) error

	SetEdge(nt NodeType, e ...EdgeData) error
	// TODO: edge type changing method
	DeleteEdge(nt NodeType, from LocalID, et EdgeTypeID, to ...ID) error
}

type TypeInfo

type TypeInfo struct {
	Type     NodeType
	DataType any
	Edges    []EdgeTypeInfo
	// contains filtered or unexported fields
}