types

package
v0.0.0-...-d6cb97c Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 14, 2018 License: Apache-2.0 Imports: 30 Imported by: 0

Documentation

Overview

Package types contains most of the data structures available to/from Noms.

Index

Examples

Constants

View Source 
const (
	DEFAULT_MAX_SPLICE_MATRIX_SIZE = 2e7
	SPLICE_UNASSIGNED              = math.MaxUint64

	UNCHANGED = 0
	UPDATED   = 1
	INSERTED  = 2
	REMOVED   = 3
)

Variables

View Source 
var BlobType = makePrimitiveType(BlobKind)
View Source 
var BoolType = makePrimitiveType(BoolKind)
View Source 
var EmptyStruct = newStruct("", nil, nil)
View Source 
var EmptyStructType = MakeStructType("")
View Source 
var KindToString = map[NomsKind]string{
	BlobKind:   "Blob",
	BoolKind:   "Bool",
	CycleKind:  "Cycle",
	ListKind:   "List",
	MapKind:    "Map",
	NumberKind: "Number",
	RefKind:    "Ref",
	SetKind:    "Set",
	StructKind: "Struct",
	StringKind: "String",
	TypeKind:   "Type",
	UnionKind:  "Union",
	ValueKind:  "Value",
}
View Source 
var NumberType = makePrimitiveType(NumberKind)
View Source 
var StringType = makePrimitiveType(StringKind)
View Source 
var TypeType = makePrimitiveType(TypeKind)
View Source 
var ValueType = makePrimitiveType(ValueKind)

Functions

func CamelCaseFieldName 

func CamelCaseFieldName(input string) string

func ContainCommonSupertype 

func ContainCommonSupertype(a, b *Type) bool

ContainCommonSupertype returns true if it's possible to synthesize a non-trivial (i.e. not empty) supertype from types |a| and |b|.

It is useful for determining whether a subset of values can be extracted from one object to produce another object.

The rules for determining whether |a| and |b| intersect are:

  • if either type is Value, return true
  • if either type is Union, return true iff at least one variant of |a| intersects with one variant of |b|
  • if |a| & |b| are not the same kind, return false
  • else
  • if both are structs, return true iff their names are equal or one name is "", they share a field name and the type of that field intersects
  • if both are refs, sets or lists, return true iff the element type intersects
  • if both are maps, return true iff they have a key with the same type and value types that intersect
  • else return true

func EncodeValue 

func EncodeValue(v Value) chunks.Chunk

func EncodedIndexValue 

func EncodedIndexValue(v Value) string

func EncodedValue 

func EncodedValue(v Value) string

EncodedValue returns a string containing the serialization of a value.

func EncodedValueMaxLines 

func EncodedValueMaxLines(v Value, maxLines uint32) string

EncodedValueMaxLines returns a string containing the serialization of a value. The string is truncated at |maxLines|.

func EnsureHash 

func EnsureHash(h *hash.Hash, v Value) hash.Hash

func EscapeStructField 

func EscapeStructField(input string) string

EscapeStructField escapes names for use as noms structs with regards to non CSV imported data. Disallowed characters are encoded as 'Q<hex-encoded-utf8-bytes>'. Note that Q itself is also escaped since it is the escape character.

func HasStructCycles 

func HasStructCycles(t *Type) bool

HasStructCycles determines if the type contains any struct cycles.

func HeightOrder 

func HeightOrder(a, b Ref) bool

HeightOrder returns true if a is 'higher than' b, generally if its ref-height is greater. If the two are of the same height, fall back to sorting by TargetHash.

func IsPrimitiveKind 

func IsPrimitiveKind(k NomsKind) bool

IsPrimitiveKind returns true if k represents a Noms primitive type, which excludes collections (List, Map, Set), Refs, Structs, Symbolic and Unresolved types.

func IsSubtype 

func IsSubtype(requiredType, concreteType *Type) bool

IsSubtype determines whether concreteType is a subtype of requiredType. For example, `Number` is a subtype of `Number | String`.

func IsSubtypeDisallowExtraStructFields 

func IsSubtypeDisallowExtraStructFields(requiredType, concreteType *Type) bool

IsSubtypeDisallowExtraFields is a slightly weird variant of IsSubtype. It returns true IFF IsSubtype(requiredType, concreteType) AND Structs in concreteType CANNOT have field names absent in requiredType ISSUE: https://github.com/attic-labs/noms/issues/3446

func IsValidStructFieldName 

func IsValidStructFieldName(name string) bool

IsValidStructFieldName returns whether the name is valid as a field name in a struct. Valid names must start with `a-zA-Z` and after that `a-zA-Z0-9_`.

func IsValueSubtypeOf 

func IsValueSubtypeOf(v Value, t *Type) bool

func IsValueSubtypeOfDetails 

func IsValueSubtypeOfDetails(v Value, t *Type) (bool, bool)

IsValueSubtypeOfDetails returns two values: 

isSub - which indicates whether v is a subtype of t.
hasExtra - which indicates whether v has additional fields. This field has
           no meaning if IsSub is false.

For example, given the following data: 

type1 := struct S {               v := Struct S1 {
    a Number | string                 a: "hello"
    b ?int                            b: 2
}                                 }

IsValueSubtypeOfDetails(v, type1) would return isSub == true, and hasExtra == false

And given these types: 

type2 := struct S {               v := Struct S1 {
    a Number | string                 a: "hello"
    b ?int                            b: 2
}                                     c: "hello again"
                                  }

IsValueSubtypeOfDetails(v, type1) would return isSub == true, and hasExtra == true

func NewStreamingList 

func NewStreamingList(vrw ValueReadWriter, values <-chan Value) <-chan List

NewStreamingList creates a new List, populated with values, chunking if and when needed. As chunks are created, they're written to vrw -- including the root chunk of the list. Once the caller has closed values, the caller can read the completed List from the returned channel.

func NewStreamingMap 

func NewStreamingMap(vrw ValueReadWriter, kvs <-chan Value) <-chan Map

NewStreamingMap takes an input channel of values and returns a output channel that will produce a finished Map. Values sent to the input channel must be alternating keys and values. (e.g. k1, v1, k2, v2...). Moreover keys need to be added to the channel in Noms sortorder, adding key values to the input channel out of order will result in a panic. Once the input channel is closed by the caller, a finished Map will be sent to the output channel. See graph_builder.go for building collections with values that are not in order.

func NewStreamingSet 

func NewStreamingSet(vrw ValueReadWriter, vChan <-chan Value) <-chan Set

NewStreamingSet takes an input channel of values and returns a output channel that will produce a finished Set. Values that are sent to the input channel must be in Noms sortorder, adding values to the input channel out of order will result in a panic. Once the input channel is closed by the caller, a finished Set will be sent to the output channel. See graph_builder.go for building collections with values that are not in order.

func PanicIfDangling 

func PanicIfDangling(unresolved hash.HashSet, cs chunks.ChunkStore)

func RegisterHRSCommenter 

func RegisterHRSCommenter(typename, unique string, commenter HRSCommenter)

RegisterHRSCommenter is called to with three arguments: 

typename: the name of the struct this function will be applied to
unique: an arbitrary string to differentiate functions that should be applied
  to different structs that have the same name (e.g. two implementations of
  the "Employee" type.
commenter: an interface with a 'Comment()' function that gets called for all
  Values with this name. The function should verify the type of the Value
  and, if appropriate, return a non-empty string to be appended as the comment

func UnregisterHRSCommenter 

func UnregisterHRSCommenter(typename, unique string)

UnregisterHRSCommenter will remove a commenter function for a specified typename/unique string combination.

func ValueCanBePathIndex 

func ValueCanBePathIndex(v Value) bool

func WalkRefs 

func WalkRefs(c chunks.Chunk, cb RefCallback)

WalkRefs calls cb() on each Ref that can be decoded from |c|. The results are precisely equal to DecodeValue(c).WalkRefs(cb), but this should be much faster.

func WalkValues 

func WalkValues(target Value, vr ValueReader, cb SkipValueCallback)

WalkValues recursively walks over all types.Values reachable from r and calls cb on them.

func WriteEncodedValue 

func WriteEncodedValue(w io.Writer, v Value) error

WriteEncodedValue writes the serialization of a value

func WriteEncodedValueMaxLines 

func WriteEncodedValueMaxLines(w io.Writer, v Value, maxLines uint32) error

WriteEncodedValueMaxLines writes the serialization of a value. Writing will be stopped and an error returned after |maxLines|.

func WriteValueStats 

func WriteValueStats(w io.Writer, v Value, vr ValueReader)

Types

type AtAnnotation 

type AtAnnotation struct {
	// Index is the position to resolve at. If negative, it means an index
	// relative to the end of the collection.
	Index int64
	// IntoKey see IndexPath.IntoKey.
	IntoKey bool
}

AtAnnotation is a PathPart annotation that gets the value of a collection at a position, rather than a key. This is equivalent to IndexPath for lists, but different for sets and maps.

func NewAtAnnotation 

func NewAtAnnotation(idx int64) AtAnnotation

func NewAtAnnotationIntoKeyPath 

func NewAtAnnotationIntoKeyPath(idx int64) AtAnnotation

func (AtAnnotation) Resolve 

func (ann AtAnnotation) Resolve(v Value, vr ValueReader) Value

func (AtAnnotation) String 

func (ann AtAnnotation) String() (str string)

type Blob 

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

Blob represents a list of Blobs.

func NewBlob 

func NewBlob(vrw ValueReadWriter, rs ...io.Reader) Blob

NewBlob creates a Blob by reading from every Reader in rs and concatenating the result. NewBlob uses one goroutine per Reader.

func NewEmptyBlob 

func NewEmptyBlob(vrw ValueReadWriter) Blob

func (Blob) Concat 

func (b Blob) Concat(other Blob) Blob

Concat returns a new Blob comprised of this joined with other. It only needs to visit the rightmost prolly tree chunks of this Blob, and the leftmost prolly tree chunks of other, so it's efficient.

func (Blob) Copy 

func (b Blob) Copy(w io.Writer) (n int64)

func (Blob) CopyReadAhead 

func (b Blob) CopyReadAhead(w io.Writer, chunkSize uint64, concurrency int) (n int64)

CopyReadAhead copies the entire contents of |b| to |w|, and attempts to stay |concurrency| |chunkSize| blocks of bytes ahead of the last byte written to |w|.

func (Blob) Edit 

func (b Blob) Edit() *BlobEditor

func (Blob) ReadAt 

func (b Blob) ReadAt(p []byte, off int64) (n int, err error)

ReadAt implements the ReaderAt interface. Eagerly loads requested byte-range from the blob p-tree.

func (Blob) Reader 

func (b Blob) Reader() *BlobReader

func (Blob) Value 

func (b Blob) Value() Value

Value interface

func (Blob) WalkValues 

func (b Blob) WalkValues(cb ValueCallback)

type BlobEditor 

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

func NewBlobEditor 

func NewBlobEditor(b Blob) *BlobEditor

func (*BlobEditor) Blob 

func (be *BlobEditor) Blob() Blob

func (*BlobEditor) Kind 

func (be *BlobEditor) Kind() NomsKind

func (*BlobEditor) Len 

func (be *BlobEditor) Len() uint64

func (*BlobEditor) Read 

func (be *BlobEditor) Read(p []byte) (n int, err error)

func (*BlobEditor) Seek 

func (be *BlobEditor) Seek(offset int64, whence int) (int64, error)

func (*BlobEditor) Splice 

func (be *BlobEditor) Splice(idx uint64, deleteCount uint64, insert []byte) *BlobEditor

func (*BlobEditor) Value 

func (be *BlobEditor) Value() Value

func (*BlobEditor) Write 

func (be *BlobEditor) Write(p []byte) (n int, err error)

type BlobReader 

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

func (*BlobReader) Read 

func (cbr *BlobReader) Read(p []byte) (n int, err error)

func (*BlobReader) Seek 

func (cbr *BlobReader) Seek(offset int64, whence int) (int64, error)

type Bool 

type Bool bool

Bool is a Noms Value wrapper around the primitive bool type.

func (Bool) Equals 

func (b Bool) Equals(other Value) bool

func (Bool) Hash 

func (b Bool) Hash() hash.Hash

func (Bool) Kind 

func (b Bool) Kind() NomsKind

func (Bool) Less 

func (b Bool) Less(other Value) bool

func (Bool) Value 

func (b Bool) Value() Value

Value interface

func (Bool) WalkRefs 

func (b Bool) WalkRefs(cb RefCallback)

func (Bool) WalkValues 

func (b Bool) WalkValues(cb ValueCallback)

type Collection 

type Collection interface {
	Value
	Emptyable
	Len() uint64
	// contains filtered or unexported methods
}

func LoadLeafNodes 

func LoadLeafNodes(cols []Collection, startIdx, endIdx uint64) ([]Collection, uint64)

LoadLeafNodes loads the set of leaf nodes which contain the items [startIdx -> endIdx). Returns the set of nodes and the offset within the first sequence which corresponds to |startIdx|.

type CompoundDesc 

type CompoundDesc struct {
	ElemTypes typeSlice
	// contains filtered or unexported fields
}

CompoundDesc describes a List, Map, Set, Ref, or Union type. ElemTypes indicates what type or types are in the container indicated by kind, e.g. Map key and value or Set element.

func (CompoundDesc) Kind 

func (c CompoundDesc) Kind() NomsKind

type CycleDesc 

type CycleDesc string

func (CycleDesc) Kind 

func (c CycleDesc) Kind() NomsKind

type DecodedChunk 

type DecodedChunk struct {
	Chunk *chunks.Chunk
	Value *Value
}

DecodedChunk holds a pointer to a Chunk and the Value that results from calling DecodeFromBytes(c.Data()).

type DiffChangeType 

type DiffChangeType uint8
const (
	DiffChangeAdded DiffChangeType = iota
	DiffChangeRemoved
	DiffChangeModified
)

type EditDistanceEqualsFn 

type EditDistanceEqualsFn func(prevIndex uint64, currentIndex uint64) bool

type Emptyable 

type Emptyable interface {
	Empty() bool
}

Emptyable is an interface for Values which may or may not be empty

type FieldMap 

type FieldMap map[string]*Type

type FieldPath 

type FieldPath struct {
	// The name of the field, e.g. `.Name`.
	Name string
}

FieldPath references Struct field values by name.

func NewFieldPath 

func NewFieldPath(name string) FieldPath

func (FieldPath) Resolve 

func (fp FieldPath) Resolve(v Value, vr ValueReader) Value

func (FieldPath) String 

func (fp FieldPath) String() string

type GraphBuilder 

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

func NewGraphBuilder 

func NewGraphBuilder(vrw ValueReadWriter, rootKind NomsKind) *GraphBuilder

NewGraphBuilder returns an new GraphBuilder object.

func (*GraphBuilder) Build 

func (b *GraphBuilder) Build() Value

Build builds and returns the graph. This method should only be called after all calls to the mutation operations (i.e. MapSet, SetInsert, and ListAppend) have completed. It is the caller's responsibility to ensure that this is the case. Build() will panic if called more than once on any GraphBuilder object.

Example 
vs := newTestValueStore()
defer vs.Close()

gb := NewGraphBuilder(vs, MapKind)
gb.SetInsert([]Value{String("parent"), String("children")}, String("John"))
gb.SetInsert([]Value{String("parent"), String("children")}, String("Mary"))
gb.SetInsert([]Value{String("parent"), String("children")}, String("Frieda"))
gb.MapSet([]Value{String("parent"), String("ages")}, String("Father"), Number(42))
gb.MapSet([]Value{String("parent"), String("ages")}, String("Mother"), Number(44))
gb.ListAppend([]Value{String("parent"), String("chores")}, String("Make dinner"))
gb.ListAppend([]Value{String("parent"), String("chores")}, String("Wash dishes"))
gb.ListAppend([]Value{String("parent"), String("chores")}, String("Make breakfast"))
gb.ListAppend([]Value{String("parent"), String("chores")}, String("Wash dishes"))
gb.MapSet([]Value{String("parent")}, String("combinedAge"), Number(86))
m := gb.Build()
fmt.Println("map:", EncodedValue(m))

Output:

func (*GraphBuilder) ListAppend 

func (b *GraphBuilder) ListAppend(keys []Value, v Value)

ListAppend will append |v| to the list at path |p|. Intermediate maps referenced by |keys| are created as necessary. This is threadsafe, may call from multiple go routines, however append semantics are such that the elements will be appended in order that functions are called, so order has to be managed by caller.

func (*GraphBuilder) MapSet 

func (b *GraphBuilder) MapSet(keys []Value, k Value, v Value)

MapSet will add the key/value pair |k, v| to the map found by traversing the graph using the |keys| slice. Intermediate maps referenced by |keys| are created as necessary. This is threadsafe, may call from multiple go routines.

func (*GraphBuilder) SetInsert 

func (b *GraphBuilder) SetInsert(keys []Value, v Value)

SetInsert will insert the value |v| into the set at path |keys|. Intermediate maps referenced by |keys| are created as necessary. This is threadsafe, may call from multiple go routines.

type HRSCommenter 

type HRSCommenter interface {
	Comment(Value) string
}

Function type for commenter functions

func GetHRSCommenters 

func GetHRSCommenters(typename string) []HRSCommenter

GetHRSCommenters the map of 'unique' strings to HRSCommentFunc for a specified typename.

type HashIndexPath 

type HashIndexPath struct {
	// The hash of the key or value to search for. Maps and Set are ordered, so
	// this in O(log(size)).
	Hash hash.Hash
	// Whether this index should resolve to the key of a map, given by a `@key`
	// annotation. Typically IntoKey is false, and indices would resolve to the
	// values. E.g. given `{a: 42}` and if the hash of `"a"` is `#abcd`, then
	// `[#abcd]` resolves to `42`. If IntoKey is true, then it resolves to `"a"`.
	// This is useful for when Map keys aren't primitive values, e.g. a struct,
	// since struct literals can't be spelled using a Path.
	IntoKey bool
}

Indexes into Maps by the hash of a key, or a Set by the hash of a value.

func NewHashIndexIntoKeyPath 

func NewHashIndexIntoKeyPath(h hash.Hash) HashIndexPath

func NewHashIndexPath 

func NewHashIndexPath(h hash.Hash) HashIndexPath

func (HashIndexPath) Resolve 

func (hip HashIndexPath) Resolve(v Value, vr ValueReader) (res Value)

func (HashIndexPath) String 

func (hip HashIndexPath) String() (str string)

type IndexPath 

type IndexPath struct {
	// The value of the index, e.g. `[42]` or `["value"]`. If Index is a negative
	// number and the path is resolved in a List, it means index from the back.
	Index Value
	// Whether this index should resolve to the key of a map, given by a `@key`
	// annotation. Typically IntoKey is false, and indices would resolve to the
	// values. E.g. given `{a: 42}` then `["a"]` resolves to `42`. If IntoKey is
	// true, then it resolves to `"a"`. For IndexPath this isn't particularly
	// useful - it's mostly provided for consistency with HashIndexPath - but
	// note that given `{a: 42}` then `["b"]` resolves to nil, not `"b"`.
	IntoKey bool
}

IndexPath ndexes into Maps and Lists by key or index.

func NewIndexIntoKeyPath 

func NewIndexIntoKeyPath(idx Value) IndexPath

func NewIndexPath 

func NewIndexPath(idx Value) IndexPath

func (IndexPath) Resolve 

func (ip IndexPath) Resolve(v Value, vr ValueReader) Value

func (IndexPath) String 

func (ip IndexPath) String() (str string)

type IntersectionIterator 

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

IntersectionIterator only returns values that are returned in both of its child iterators. The values from Next() are returned in noms-defined order with all duplicates removed.

func (*IntersectionIterator) Next 

func (i *IntersectionIterator) Next() Value

func (*IntersectionIterator) SkipTo 

func (i *IntersectionIterator) SkipTo(v Value) Value

type List 

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

List represents a list or an array of Noms values. A list can contain zero or more values of zero or more types. The type of the list will reflect the type of the elements in the list. For example: 

l := NewList(Number(1), Bool(true))
fmt.Println(l.Type().Describe())
// outputs List<Bool | Number>

Lists, like all Noms values are immutable so the "mutation" methods return a new list.

func NewList 

func NewList(vrw ValueReadWriter, values ...Value) List

NewList creates a new List where the type is computed from the elements in the list, populated with values, chunking if and when needed.

func (List) Concat 

func (l List) Concat(other List) List

Concat returns a new List comprised of this joined with other. It only needs to visit the rightmost prolly tree chunks of this List, and the leftmost prolly tree chunks of other, so it's efficient.

func (List) Diff 

func (l List) Diff(last List, changes chan<- Splice, closeChan <-chan struct{})

Diff streams the diff from last to the current list to the changes channel. Caller can close closeChan to cancel the diff operation.

func (List) DiffWithLimit 

func (l List) DiffWithLimit(last List, changes chan<- Splice, closeChan <-chan struct{}, maxSpliceMatrixSize uint64)

DiffWithLimit streams the diff from last to the current list to the changes channel. Caller can close closeChan to cancel the diff operation. The maxSpliceMatrixSize determines the how big of an edit distance matrix we are willing to compute versus just saying the thing changed.

func (List) Edit 

func (l List) Edit() *ListEditor

func (List) Get 

func (l List) Get(idx uint64) Value

Get returns the value at the given index. If this list has been chunked then this will have to descend into the prolly-tree which leads to Get being O(depth).

func (List) Iter 

func (l List) Iter(f func(v Value, index uint64) (stop bool))

Iter iterates over the list and calls f for every element in the list. If f returns true then the iteration stops.

func (List) IterAll 

func (l List) IterAll(f func(v Value, index uint64))

IterAll iterates over the list and calls f for every element in the list. Unlike Iter there is no way to stop the iteration and all elements are visited.

func (List) IterRange 

func (l List) IterRange(startIdx, endIdx uint64, f func(v Value, idx uint64))

func (List) Iterator 

func (l List) Iterator() ListIterator

Iterator returns a ListIterator which can be used to iterate efficiently over a list.

func (List) IteratorAt 

func (l List) IteratorAt(index uint64) ListIterator

IteratorAt returns a ListIterator starting at index. If index is out of bound the iterator will have reached its end on creation.

func (List) Value 

func (l List) Value() Value

Value interface

func (List) WalkValues 

func (l List) WalkValues(cb ValueCallback)

type ListEditor 

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

func NewListEditor 

func NewListEditor(l List) *ListEditor

func (*ListEditor) Append 

func (le *ListEditor) Append(vs ...Valuable) *ListEditor

func (*ListEditor) Get 

func (le *ListEditor) Get(idx uint64) Valuable

func (*ListEditor) Insert 

func (le *ListEditor) Insert(idx uint64, vs ...Valuable) *ListEditor

func (*ListEditor) Kind 

func (le *ListEditor) Kind() NomsKind

func (*ListEditor) Len 

func (le *ListEditor) Len() uint64

func (*ListEditor) List 

func (le *ListEditor) List() List

func (*ListEditor) Remove 

func (le *ListEditor) Remove(start uint64, end uint64) *ListEditor

func (*ListEditor) RemoveAt 

func (le *ListEditor) RemoveAt(idx uint64) *ListEditor

func (*ListEditor) Set 

func (le *ListEditor) Set(idx uint64, v Valuable) *ListEditor

func (*ListEditor) Splice 

func (le *ListEditor) Splice(idx uint64, deleteCount uint64, vs ...Valuable) *ListEditor

func (*ListEditor) Value 

func (le *ListEditor) Value() Value

type ListIterator 

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

ListIterator can be used to efficiently iterate through a Noms List.

func (ListIterator) Next 

func (li ListIterator) Next() (out Value)

Next returns subsequent Values from a List, starting with the index at which the iterator was created. If there are no more Values, Next() returns nil.

type Map 

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

func NewMap 

func NewMap(vrw ValueReadWriter, kv ...Value) Map

func (Map) Any 

func (m Map) Any(cb func(k, v Value) bool) (yep bool)

Any returns true if cb() return true for any of the items in the map.

func (Map) At 

func (m Map) At(idx uint64) (key, value Value)

func (Map) Diff 

func (m Map) Diff(last Map, changes chan<- ValueChanged, closeChan <-chan struct{})

Diff computes the diff from |last| to |m| using the top-down algorithm, which completes as fast as possible while taking longer to return early results than left-to-right.

func (Map) DiffHybrid 

func (m Map) DiffHybrid(last Map, changes chan<- ValueChanged, closeChan <-chan struct{})

DiffHybrid computes the diff from |last| to |m| using a hybrid algorithm which balances returning results early vs completing quickly, if possible.

func (Map) DiffLeftRight 

func (m Map) DiffLeftRight(last Map, changes chan<- ValueChanged, closeChan <-chan struct{})

DiffLeftRight computes the diff from |last| to |m| using a left-to-right streaming approach, optimised for returning results early, but not completing quickly.

func (Map) Edit 

func (m Map) Edit() *MapEditor

func (Map) First 

func (m Map) First() (Value, Value)

func (Map) Get 

func (m Map) Get(key Value) Value

func (Map) Has 

func (m Map) Has(key Value) bool

func (Map) Iter 

func (m Map) Iter(cb mapIterCallback)

func (Map) IterAll 

func (m Map) IterAll(cb mapIterAllCallback)

func (Map) IterFrom 

func (m Map) IterFrom(start Value, cb mapIterCallback)

func (Map) Iterator 

func (m Map) Iterator() MapIterator

func (Map) IteratorAt 

func (m Map) IteratorAt(pos uint64) MapIterator

func (Map) IteratorFrom 

func (m Map) IteratorFrom(key Value) MapIterator

func (Map) Last 

func (m Map) Last() (Value, Value)

func (Map) MaybeGet 

func (m Map) MaybeGet(key Value) (v Value, ok bool)

func (Map) Value 

func (m Map) Value() Value

Value interface

func (Map) WalkValues 

func (m Map) WalkValues(cb ValueCallback)

type MapEditor 

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

MapEditor allows for efficient editing of Map-typed prolly trees. Edits are buffered to memory and can be applied via Build(), which returns a new Map. Prior to Build(), Get() & Has() will return the value that the resulting Map would return if it were built immediately prior to the respective call. Note: The implementation biases performance towards a usage which applies edits in key-order.

func NewMapEditor 

func NewMapEditor(m Map) *MapEditor

func (*MapEditor) Get 

func (me *MapEditor) Get(k Value) Valuable

func (*MapEditor) Has 

func (me *MapEditor) Has(k Value) bool

func (*MapEditor) Kind 

func (me *MapEditor) Kind() NomsKind

func (*MapEditor) Map 

func (me *MapEditor) Map() Map

func (*MapEditor) Remove 

func (me *MapEditor) Remove(k Value) *MapEditor

func (*MapEditor) Set 

func (me *MapEditor) Set(k Value, v Valuable) *MapEditor

func (*MapEditor) SetM 

func (me *MapEditor) SetM(kv ...Valuable) *MapEditor

func (*MapEditor) Value 

func (me *MapEditor) Value() Value

type MapIterator 

type MapIterator interface {
	Next() (k, v Value)
}

MapIterator is the interface used by iterators over Noms Maps.

type NomsKind 

type NomsKind uint8

NomsKind allows a TypeDesc to indicate what kind of type is described. 

const (
	BoolKind NomsKind = iota
	NumberKind
	StringKind
	BlobKind
	ValueKind
	ListKind
	MapKind
	RefKind
	SetKind

	// Keep StructKind and CycleKind together.
	StructKind
	CycleKind

	TypeKind
	UnionKind
)

All supported kinds of Noms types are enumerated here. The ordering of these (especially Bool, Number and String) is important for ordering of values.

func (NomsKind) String 

func (k NomsKind) String() string

String returns the name of the kind.

type Number 

type Number float64

Number is a Noms Value wrapper around the primitive float64 type.

func (Number) Equals 

func (v Number) Equals(other Value) bool

func (Number) Hash 

func (v Number) Hash() hash.Hash

func (Number) Kind 

func (v Number) Kind() NomsKind

func (Number) Less 

func (v Number) Less(other Value) bool

func (Number) Value 

func (v Number) Value() Value

Value interface

func (Number) WalkRefs 

func (v Number) WalkRefs(cb RefCallback)

func (Number) WalkValues 

func (v Number) WalkValues(cb ValueCallback)

type Path 

type Path []PathPart

A Path locates a value in Noms relative to some other value. For locating values absolutely within a database, see AbsolutePath. To locate values globally, see Spec.

For more details, see: https://github.com/attic-labs/noms/blob/master/doc/spelling.md.

func MustParsePath 

func MustParsePath(str string) Path

MustParsePath parses str into a Path, or panics if parsing failed.

func ParsePath 

func ParsePath(str string) (Path, error)

ParsePath parses str into a Path, or returns an error if parsing failed.

func (Path) Append 

func (p Path) Append(pp PathPart) Path

Append makes a copy of a p and appends the PathPart 'pp' to it.

func (Path) Equals 

func (p Path) Equals(o Path) bool

func (Path) IsEmpty 

func (p Path) IsEmpty() bool

func (Path) Resolve 

func (p Path) Resolve(v Value, vr ValueReader) (resolved Value)

Resolve resolves a path relative to some value. A ValueReader is required to resolve paths that contain the @target annotation.

func (Path) String 

func (p Path) String() string

type PathPart 

type PathPart interface {
	Resolve(v Value, vr ValueReader) Value
	String() string
}

type PrimitiveDesc 

type PrimitiveDesc NomsKind

PrimitiveDesc implements TypeDesc for all primitive Noms types: Blob Bool Number String Type Value

func (PrimitiveDesc) Kind 

func (p PrimitiveDesc) Kind() NomsKind

type Ref 

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

func NewRef 

func NewRef(v Value) Ref

func ToRefOfValue 

func ToRefOfValue(r Ref) Ref

ToRefOfValue returns a new Ref that points to the same target as |r|, but with the type 'Ref<Value>'.

func (Ref) Equals 

func (v Ref) Equals(other Value) bool

func (Ref) Hash 

func (v Ref) Hash() hash.Hash

func (Ref) Height 

func (r Ref) Height() uint64

func (Ref) IsZeroValue 

func (v Ref) IsZeroValue() bool

IsZeroValue can be used to test if a Value is the same as T{}.

func (Ref) Kind 

func (v Ref) Kind() NomsKind

func (Ref) Less 

func (v Ref) Less(other Value) bool

func (Ref) TargetHash 

func (r Ref) TargetHash() hash.Hash

func (Ref) TargetType 

func (r Ref) TargetType() *Type

func (Ref) TargetValue 

func (r Ref) TargetValue(vr ValueReader) Value

func (Ref) Value 

func (r Ref) Value() Value

Value interface

func (Ref) WalkRefs 

func (v Ref) WalkRefs(cb RefCallback)

func (Ref) WalkValues 

func (r Ref) WalkValues(cb ValueCallback)

type RefByHeight 

type RefByHeight []Ref

RefByHeight implements sort.Interface to order by increasing HeightOrder(). It uses increasing order because this causes repeated pushes and pops of the 'tallest' Refs to re-use memory, avoiding reallocations. We might consider making this a firmer abstraction boundary as a part of BUG 2182

func (*RefByHeight) DropIndices 

func (h *RefByHeight) DropIndices(indices []int)

DropIndices takes a slice of integer indices into h and splices out the Refs at those indices.

func (RefByHeight) Empty 

func (h RefByHeight) Empty() bool

func (RefByHeight) Len 

func (h RefByHeight) Len() int

func (RefByHeight) Less 

func (h RefByHeight) Less(i, j int) bool

func (RefByHeight) MaxHeight 

func (h RefByHeight) MaxHeight() uint64

MaxHeight returns the height of the 'tallest' Ref in h.

func (RefByHeight) PeekAt 

func (h RefByHeight) PeekAt(idx int) (peek Ref)

PeekAt returns, but does not remove, the Ref at h[idx]. If the index is out of range, returns the empty Ref.

func (RefByHeight) PeekEnd 

func (h RefByHeight) PeekEnd() (head Ref)

PeekEnd returns, but does not Pop the tallest Ref in h.

func (*RefByHeight) PopBack 

func (h *RefByHeight) PopBack() Ref

func (*RefByHeight) PopRefsOfHeight 

func (h *RefByHeight) PopRefsOfHeight(height uint64) (refs RefSlice)

PopRefsOfHeight pops off and returns all refs r in h for which r.Height() == height.

func (*RefByHeight) PushBack 

func (h *RefByHeight) PushBack(r Ref)

func (RefByHeight) Swap 

func (h RefByHeight) Swap(i, j int)

func (*RefByHeight) Unique 

func (h *RefByHeight) Unique()

type RefCallback 

type RefCallback func(ref Ref)

type RefSlice 

type RefSlice []Ref

RefSlice implements sort.Interface to order by target ref.

func (RefSlice) Len 

func (s RefSlice) Len() int

func (RefSlice) Less 

func (s RefSlice) Less(i, j int) bool

func (RefSlice) Swap 

func (s RefSlice) Swap(i, j int)

type Set 

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

func NewSet 

func NewSet(vrw ValueReadWriter, v ...Value) Set

func (Set) At 

func (s Set) At(idx uint64) Value

func (Set) Diff 

func (s Set) Diff(last Set, changes chan<- ValueChanged, closeChan <-chan struct{})

Diff computes the diff from |last| to |m| using the top-down algorithm, which completes as fast as possible while taking longer to return early results than left-to-right.

func (Set) DiffHybrid 

func (s Set) DiffHybrid(last Set, changes chan<- ValueChanged, closeChan <-chan struct{})

DiffHybrid computes the diff from |last| to |s| using a hybrid algorithm which balances returning results early vs completing quickly, if possible.

func (Set) DiffLeftRight 

func (s Set) DiffLeftRight(last Set, changes chan<- ValueChanged, closeChan <-chan struct{})

DiffLeftRight computes the diff from |last| to |s| using a left-to-right streaming approach, optimised for returning results early, but not completing quickly.

func (Set) Edit 

func (s Set) Edit() *SetEditor

func (Set) First 

func (s Set) First() Value

func (Set) Has 

func (s Set) Has(v Value) bool

func (Set) Iter 

func (s Set) Iter(cb setIterCallback)

func (Set) IterAll 

func (s Set) IterAll(cb setIterAllCallback)

func (Set) Iterator 

func (s Set) Iterator() SetIterator

func (Set) IteratorAt 

func (s Set) IteratorAt(idx uint64) SetIterator

func (Set) IteratorFrom 

func (s Set) IteratorFrom(val Value) SetIterator

func (Set) Value 

func (s Set) Value() Value

Value interface

func (Set) WalkValues 

func (s Set) WalkValues(cb ValueCallback)

type SetEditor 

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

SetEditor allows for efficient editing of Set-typed prolly trees. Edits are buffered to memory and can be applied via Build(), which returns a new Set. Prior to Build(), Get() & Has() will return the value that the resulting Set would return if it were built immediately prior to the respective call. Note: The implementation biases performance towards a usage which applies edits in key-order.

func NewSetEditor 

func NewSetEditor(s Set) *SetEditor

func (*SetEditor) Has 

func (se *SetEditor) Has(v Value) bool

func (*SetEditor) Insert 

func (se *SetEditor) Insert(vs ...Value) *SetEditor

func (*SetEditor) Kind 

func (se *SetEditor) Kind() NomsKind

func (*SetEditor) Remove 

func (se *SetEditor) Remove(vs ...Value) *SetEditor

func (*SetEditor) Set 

func (se *SetEditor) Set() Set

func (*SetEditor) Value 

func (se *SetEditor) Value() Value

type SetIterator 

type SetIterator interface {
	// Next returns subsequent values from a set. It returns nil, when no objects remain.
	Next() Value

	// SkipTo(v) advances to and returns the next value in the iterator >= v.
	// Note: if the iterator has already returned the value being skipped to, it will return the next
	// value (just as if Next() was called). For example, given the following set:
	//   s = Set{ 0, 3, 6, 9, 12, 15, 18 }
	// An iterator on the set would return:
	//   i := s.Iterator()
	//   i.Next()  return 0
	//   i.SkipTo(4) -- returns 6
	//   i.skipTo(3) -- returns 9 (this is the next value in the iterator >= 3)
	//   i.skipTo(12) -- returns 12
	//   i.skipTo(12) -- return 15 (this is the next value in the iterator >= 12)
	//   i.skipTo(20) -- returns nil
	// If there are no values left in the iterator that are >= v,
	// the iterator will skip to the end of the sequence and return nil.
	SkipTo(v Value) Value
}

SetIterator defines methods that can be used to efficiently iterate through a set in 'Noms-defined' sorted order.

func NewIntersectionIterator 

func NewIntersectionIterator(iterA, iterB SetIterator) SetIterator

NewIntersectionIterator creates a intersect iterator from two other SetIterators.

func NewUnionIterator 

func NewUnionIterator(iterA, iterB SetIterator) SetIterator

NewUnionIterator creates a union iterator from two other SetIterators.

type SkipValueCallback 

type SkipValueCallback func(v Value) bool

type Splice 

type Splice struct {
	SpAt      uint64
	SpRemoved uint64
	SpAdded   uint64
	SpFrom    uint64
}

Read a Splice as "at SpAt (in the previous state), SpRemoved elements were removed and SpAdded elements were inserted, which can be found starting at SpFrom in the current state"

func (Splice) String 

func (s Splice) String() string

type String 

type String string

String is a Noms Value wrapper around the primitive string type.

func (String) Equals 

func (s String) Equals(other Value) bool

func (String) Hash 

func (s String) Hash() hash.Hash

func (String) Kind 

func (s String) Kind() NomsKind

func (String) Less 

func (s String) Less(other Value) bool

func (String) Value 

func (s String) Value() Value

Value interface

func (String) WalkRefs 

func (s String) WalkRefs(cb RefCallback)

func (String) WalkValues 

func (s String) WalkValues(cb ValueCallback)

type Struct 

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

func NewStruct 

func NewStruct(name string, data StructData) Struct

func (Struct) Delete 

func (s Struct) Delete(n string) Struct

Delete returns a new struct where the field name has been removed. If name is not an existing field in the struct then the current struct is returned.

func (Struct) Diff 

func (s Struct) Diff(last Struct, changes chan<- ValueChanged, closeChan <-chan struct{})

func (Struct) Empty 

func (s Struct) Empty() bool

func (Struct) Equals 

func (v Struct) Equals(other Value) bool

func (Struct) Get 

func (s Struct) Get(n string) Value

Get returns the value of a field in the struct. If the struct does not a have a field with the name name then this panics.

func (Struct) Hash 

func (v Struct) Hash() hash.Hash

func (Struct) IsZeroValue 

func (v Struct) IsZeroValue() bool

IsZeroValue can be used to test if a Value is the same as T{}.

func (Struct) IterFields 

func (s Struct) IterFields(cb func(name string, value Value))

IterFields iterates over the fields, calling cb for every field in the struct.

func (Struct) Kind 

func (v Struct) Kind() NomsKind

func (Struct) Len 

func (s Struct) Len() int

Len is the number of fields in the struct.

func (Struct) Less 

func (v Struct) Less(other Value) bool

func (Struct) MaybeGet 

func (s Struct) MaybeGet(n string) (v Value, found bool)

MaybeGet returns the value of a field in the struct. If the struct does not a have a field with the name name then this returns (nil, false).

func (Struct) Name 

func (s Struct) Name() string

Name is the name of the struct.

func (Struct) Set 

func (s Struct) Set(n string, v Value) Struct

Set returns a new struct where the field name has been set to value. If name is not an existing field in the struct or the type of value is different from the old value of the struct field a new struct type is created.

func (Struct) Value 

func (s Struct) Value() Value

Value interface

func (Struct) WalkRefs 

func (v Struct) WalkRefs(cb RefCallback)

func (Struct) WalkValues 

func (s Struct) WalkValues(cb ValueCallback)

type StructData 

type StructData map[string]Value

type StructDesc 

type StructDesc struct {
	Name string
	// contains filtered or unexported fields
}

StructDesc describes a custom Noms Struct.

func (StructDesc) Field 

func (s StructDesc) Field(name string) (typ *Type, optional bool)

func (StructDesc) IterFields 

func (s StructDesc) IterFields(cb func(name string, t *Type, optional bool))

func (StructDesc) Kind 

func (s StructDesc) Kind() NomsKind

func (StructDesc) Len 

func (s StructDesc) Len() int

Len returns the number of fields in the struct

type StructField 

type StructField struct {
	Name     string
	Type     *Type
	Optional bool
}

StructField describes a field in a struct type.

type StructTemplate 

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

StructTemplate allows creating a template for structs with a known shape (name and fields). If a lot of structs of the same shape are being created then using a StructTemplate makes that slightly more efficient.

func MakeStructTemplate 

func MakeStructTemplate(name string, fieldNames []string) (t StructTemplate)

MakeStructTemplate creates a new StructTemplate or panics if the name and fields are not valid.

func (StructTemplate) NewStruct 

func (st StructTemplate) NewStruct(values []Value) Struct

NewStruct creates a new Struct from the StructTemplate. The order of the values must match the order of the field names of the StructTemplate.

type TargetAnnotation 

type TargetAnnotation struct {
}

TargetAnnotation is a PathPart annotation to resolve to the targetValue of the Ref it is resolved on.

func (TargetAnnotation) Resolve 

func (ann TargetAnnotation) Resolve(v Value, vr ValueReader) Value

func (TargetAnnotation) String 

func (ann TargetAnnotation) String() string

type Type 

type Type struct {
	Desc TypeDesc
}

func MakeCycleType 

func MakeCycleType(name string) *Type

func MakeListType 

func MakeListType(elemType *Type) *Type

func MakeMapType 

func MakeMapType(keyType, valType *Type) *Type

func MakePrimitiveType 

func MakePrimitiveType(k NomsKind) *Type

func MakeRefType 

func MakeRefType(elemType *Type) *Type

func MakeSetType 

func MakeSetType(elemType *Type) *Type

func MakeStructType 

func MakeStructType(name string, fields ...StructField) *Type

func MakeStructTypeFromFields 

func MakeStructTypeFromFields(name string, fields FieldMap) *Type

func MakeUnionType 

func MakeUnionType(elemTypes ...*Type) *Type

MakeUnionType creates a new union type unless the elemTypes can be folded into a single non union type.

func MakeUnionTypeIntersectStructs 

func MakeUnionTypeIntersectStructs(elemTypes ...*Type) *Type

MakeUnionTypeIntersectStructs is a bit of strange function. It creates a simplified union type except for structs, where it creates interesection types. This function will go away so do not use it!

func TypeOf 

func TypeOf(v Value) *Type

TypeOf returns the type describing the value. This is not an exact type but often a simplification of the concrete type.

func (*Type) Describe 

func (t *Type) Describe() (out string)

Describe generate text that should parse into the struct being described.

func (*Type) Equals 

func (t *Type) Equals(other Value) (res bool)

func (*Type) Hash 

func (t *Type) Hash() hash.Hash

func (*Type) Kind 

func (t *Type) Kind() NomsKind

func (*Type) Less 

func (t *Type) Less(other Value) (res bool)

func (*Type) TargetKind 

func (t *Type) TargetKind() NomsKind

func (*Type) Value 

func (t *Type) Value() Value

Value interface

func (*Type) WalkRefs 

func (t *Type) WalkRefs(cb RefCallback)

func (*Type) WalkValues 

func (t *Type) WalkValues(cb ValueCallback)

type TypeAnnotation 

type TypeAnnotation struct {
}

TypeAnnotation is a PathPart annotation to resolve to the type of the value it's resolved in.

func (TypeAnnotation) Resolve 

func (ann TypeAnnotation) Resolve(v Value, vr ValueReader) Value

func (TypeAnnotation) String 

func (ann TypeAnnotation) String() string

type TypeDesc 

type TypeDesc interface {
	Kind() NomsKind
	// contains filtered or unexported methods
}

TypeDesc describes a type of the kind returned by Kind(), e.g. Map, Number, or a custom type.

type UnionIterator 

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

UnionIterator combines the results from two other iterators. The values from Next() are returned in noms-defined order with all duplicates removed.

func (*UnionIterator) Next 

func (u *UnionIterator) Next() Value

func (*UnionIterator) SkipTo 

func (u *UnionIterator) SkipTo(v Value) Value

type ValidatingDecoder 

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

func NewValidatingDecoder 

func NewValidatingDecoder(cs chunks.ChunkStore) *ValidatingDecoder

func (*ValidatingDecoder) Decode 

func (vbs *ValidatingDecoder) Decode(c *chunks.Chunk) DecodedChunk

Decode decodes c and checks that the hash of the resulting value matches c.Hash(). It returns a DecodedChunk holding both c and a pointer to the decoded Value.

type Valuable 

type Valuable interface {
	// Kind is the NomsKind describing the kind of value this is.
	Kind() NomsKind

	Value() Value
}

Valuable is an interface from which a Value can be retrieved.

type Value 

type Value interface {
	Valuable

	// Equals determines if two different Noms values represents the same underlying value.
	Equals(other Value) bool

	// Less determines if this Noms value is less than another Noms value.
	// When comparing two Noms values and both are comparable and the same type (Bool, Number or
	// String) then the natural ordering is used. For other Noms values the Hash of the value is
	// used. When comparing Noms values of different type the following ordering is used:
	// Bool < Number < String < everything else.
	Less(other Value) bool

	// Hash is the hash of the value. All Noms values have a unique hash and if two values have the
	// same hash they must be equal.
	Hash() hash.Hash

	// WalkValues iterates over the immediate children of this value in the DAG, if any, not including
	// Type()
	WalkValues(ValueCallback)

	// WalkRefs iterates over the refs to the underlying chunks. If this value is a collection that has been
	// chunked then this will return the refs of th sub trees of the prolly-tree.
	WalkRefs(RefCallback)
	// contains filtered or unexported methods
}

Value is the interface all Noms values implement.

func DecodeFromBytes 

func DecodeFromBytes(data []byte, vrw ValueReadWriter) Value

func DecodeValue 

func DecodeValue(c chunks.Chunk, vrw ValueReadWriter) Value

DecodeValue decodes a value from a chunk source. It is an error to provide an empty chunk.

func ParsePathIndex 

func ParsePathIndex(str string) (idx Value, h hash.Hash, rem string, err error)

Parse a Noms value from the path index syntax. 4 -> types.Number "4" -> types.String true|false -> types.Boolean #<chars> -> hash.Hash

type ValueCallback 

type ValueCallback func(v Value)

type ValueChanged 

type ValueChanged struct {
	ChangeType              DiffChangeType
	Key, OldValue, NewValue Value
}

type ValueReadWriter 

type ValueReadWriter interface {
	ValueReader
	ValueWriter
}

ValueReadWriter is an interface that knows how to read and write Noms Values, e.g. datas/Database. Required to avoid import cycle between this package and the package that implements Value read/writing.

type ValueReader 

type ValueReader interface {
	ReadValue(h hash.Hash) Value
	ReadManyValues(hashes hash.HashSlice) ValueSlice
}

ValueReader is an interface that knows how to read Noms Values, e.g. datas/Database. Required to avoid import cycle between this package and the package that implements Value reading.

type ValueSlice 

type ValueSlice []Value

func (ValueSlice) Contains 

func (vs ValueSlice) Contains(v Value) bool

func (ValueSlice) Equals 

func (vs ValueSlice) Equals(other ValueSlice) bool

func (ValueSlice) Len 

func (vs ValueSlice) Len() int

func (ValueSlice) Less 

func (vs ValueSlice) Less(i, j int) bool

func (ValueSlice) Swap 

func (vs ValueSlice) Swap(i, j int)

type ValueStats 

type ValueStats interface {
	String() string
}

type ValueStore 

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

ValueStore provides methods to read and write Noms Values to a ChunkStore. It minimally validates Values as they're written, but does not guarantee that these Values are persisted through the ChunkStore until a subsequent Flush. Currently, WriteValue validates the following properties of a Value v: - v can be correctly serialized and its Ref taken

func NewValueStore 

func NewValueStore(cs chunks.ChunkStore) *ValueStore

NewValueStore returns a ValueStore instance that owns the provided ChunkStore and manages its lifetime. Calling Close on the returned ValueStore will Close() cs.

func (*ValueStore) ChunkStore 

func (lvs *ValueStore) ChunkStore() chunks.ChunkStore

func (*ValueStore) Close 

func (lvs *ValueStore) Close() error

Close closes the underlying ChunkStore

func (*ValueStore) Commit 

func (lvs *ValueStore) Commit(current, last hash.Hash) bool

Commit() flushes all bufferedChunks into the ChunkStore, with best-effort locality, and attempts to Commit, updating the root to |current| (or keeping it the same as Root()). If the root has moved since this ValueStore was opened, or last Rebased(), it will return false and will have internally rebased. Until Commit() succeeds, no work of the ValueStore will be visible to other readers of the underlying ChunkStore.

func (*ValueStore) ReadManyValues 

func (lvs *ValueStore) ReadManyValues(hashes hash.HashSlice) ValueSlice

ReadManyValues reads and decodes Values indicated by |hashes| from lvs and returns the found Values in the same order. Any non-present Values will be represented by nil.

func (*ValueStore) ReadValue 

func (lvs *ValueStore) ReadValue(h hash.Hash) Value

ReadValue reads and decodes a value from lvs. It is not considered an error for the requested chunk to be empty; in this case, the function simply returns nil.

func (*ValueStore) Rebase 

func (lvs *ValueStore) Rebase()

func (*ValueStore) Root 

func (lvs *ValueStore) Root() hash.Hash

func (*ValueStore) SetEnforceCompleteness 

func (lvs *ValueStore) SetEnforceCompleteness(enforce bool)

func (*ValueStore) WriteValue 

func (lvs *ValueStore) WriteValue(v Value) Ref

WriteValue takes a Value, schedules it to be written it to lvs, and returns an appropriately-typed types.Ref. v is not guaranteed to be actually written until after Flush().

type ValueWriter 

type ValueWriter interface {
	WriteValue(v Value) Ref
}

ValueWriter is an interface that knows how to write Noms Values, e.g. datas/Database. Required to avoid import cycle between this package and the package that implements Value writing.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.