origins

type Buffer ¶

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

Buffer holds a slice of facts. The buffer dynamically grows as facts are written to it. The position is maintained across reads.

func NewBuffer(buf Facts) *Buffer

func (b *Buffer) Append(buf ...*Fact) (int, error)

func (b *Buffer) Err() error

func (b *Buffer) Facts() Facts

func (b *Buffer) Grow(n int)

func (b *Buffer) Len() int

func (b *Buffer) Next() *Fact

func (b *Buffer) Reset()

func (b *Buffer) Truncate(n int)

func (b *Buffer) Write(f *Fact) error

type CSVReader ¶

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

func NewCSVReader(r io.Reader) *CSVReader

func (r *CSVReader) Err() error

func (r *CSVReader) Next() *Fact

type CSVWriter ¶

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

func NewCSVWriter(w io.Writer) *CSVWriter

func (w *CSVWriter) Flush() error

func (w *CSVWriter) Write(f *Fact) error

type Comparator ¶

type Comparator func(f1, f2 *Fact) bool

Comparator is a function type that compares two facts for the purposes of sorting. It returns true if the first fact should come before the second fact.

type Fact ¶

type Fact struct {
	// Denotes whether the fact is asserted or retracted.
	Operation Operation

	// The domain the fact applies to. The motivation is to enable asserting
	// facts about entities in different domains. This model decouples content
	// from context to support auxillary information.
	Domain string

	// The entity, attribute, and value of the fact. Also referred to as a
	// "triple", these make up the content of the fact. The entity and attribute
	// must have a domain associated with it. If not specified, they default to
	// the fact domain. If a value has a domain specified, it will be interpreted
	// as a reference to an entity, otherwise it will be treated as a literal.
	Entity    *Ident
	Attribute *Ident
	Value     *Ident

	// The time the fact is true in the world. Also known as the "valid time",
	// this can be set if the fact is true at an earlier or later time than
	// when it was added.
	Time time.Time

	// Transaction that processed this fact. The transaction serves as the
	// temporal component of the fact. Time-travel queries rely on the
	// transaction time to filter out facts not applicable in the specified
	// time range.
	Transaction uint64
}

Fact is the fundamental unit of the information model. It is an immutable declaration of something that is true.

func First(iter Iterator, predicate func(*Fact) bool) *Fact

func (f *Fact) MarshalJSON() ([]byte, error)

func (f *Fact) String() string

type Facts ¶

type Facts []*Fact

Facts is a slice of facts.

func ReadAll(it Iterator) (Facts, error)

func Reflect(v interface{}) (Facts, error)

func (fs Facts) String() string

type FactsIterator ¶

type FactsIterator interface {
	Next() Facts
	Err() error
}

func Groupby(iter Iterator, cmp func(f1, f2 *Fact) bool) FactsIterator

type Flusher ¶

type Flusher interface {
	Flush() error
}

Flusher is an interface that defines the Flush method. Types that are buffered and require being *flushed* at the end of processing implement this method.

type Ident ¶

type Ident struct {
	Domain string
	Name   string
}

Ident models an identity of something. For entities and attributes a domain is required. For values, if the domain is ommitted, the identity is considered a literal value.

func NewIdent(domain, name string) (*Ident, error)

func ParseIdent(s string) (*Ident, error)

func (id *Ident) Is(b *Ident) bool

func (id *Ident) String() string

type Identifier ¶

type Identifier interface {
	Ident() *Ident
}

Identifier defines the Ident method that returns and Ident value. Types that implement will used during reflection to be properly represented as facts.

type Idents ¶

type Idents []*Ident

Idents is a slice of idents.

func Attributes(iter Iterator) (Idents, error)

func Entities(iter Iterator) (Idents, error)

func Values(iter Iterator) (Idents, error)

func (ids Idents) Len() int

func (ids Idents) Less(i, j int) bool

func (ids Idents) Swap(i, j int)

type Iterator ¶

type Iterator interface {
	// Next returns the next available fact in the stream.
	Next() *Fact

	// Err returns an error if one occurred while iterating facts.
	Err() error
}

Iterator is an interface that reads from an underlying stream of facts and makes facts available through the Next() method. The usage of the this interface is as follows:

// The fact will be nil if the underlying stream is exhaused
// or an error occurred.
for f := it.Next(); f != nil {
	// Do something with the fact
}

if err := it.Err(); err != nil {
	// Handle the error.
}

func Entity(iter Iterator, id *Ident) Iterator

func Filter(iter Iterator, predicate func(*Fact) bool) Iterator

func Slice(iter Iterator, offset, limit int) Iterator

type Operation ¶

type Operation int8

Operation denotes the validity of a fact. A fact can be asserted in which case it is deemed valid and true or retracted which denotes the fact is no longer valid or true. A fact may be retracted without being asserted first. This denotes some fact is known not to be true without necessarily knowing what is true.

const (
	Assertion Operation = iota
	Retraction
)

func ParseOperation(s string) (Operation, error)

func (o Operation) MarshalJSON() ([]byte, error)

func (o Operation) String() string

type UniversalReader ¶

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

UniversalReader wraps an io.Reader and replaces carriage returns with newlines.

func NewUniversalReader(r io.Reader) *UniversalReader

func (c *UniversalReader) Read(buf []byte) (int, error)

type Writer ¶

type Writer interface {
	// Write writes a fact to the underlying stream.
	Write(*Fact) error
}

Writer is an interface that defines the Write method. It takes a fact and writes it to the underlying value.