forked from cayleygraph/cayley
-
Notifications
You must be signed in to change notification settings - Fork 0
/
values.go
129 lines (113 loc) · 2.89 KB
/
values.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
package graph
import (
"encoding/hex"
"fmt"
"github.com/cayleygraph/cayley/quad"
)
// Value defines an opaque "quad store value" type. However the backend wishes
// to implement it, a Value is merely a token to a quad or a node that the
// backing store itself understands, and the base iterators pass around.
//
// For example, in a very traditional, graphd-style graph, these are int64s
// (guids of the primitives). In a very direct sort of graph, these could be
// pointers to structs, or merely quads, or whatever works best for the
// backing store.
//
// These must be comparable, or return a comparable version on Key.
type Value interface {
Key() interface{}
}
func HashOf(s quad.Value) (out ValueHash) {
if s == nil {
return
}
quad.HashTo(s, out[:])
return
}
var _ Value = ValueHash{}
// ValueHash is a hash of a single value.
type ValueHash [quad.HashSize]byte
func (h ValueHash) Valid() bool {
return h != ValueHash{}
}
func (h ValueHash) Key() interface{} { return h }
func (h ValueHash) String() string {
if !h.Valid() {
return ""
}
return hex.EncodeToString(h[:])
}
// PreFetchedValue is an optional interface for graph.Value to indicate that
// quadstore has already loaded a value into memory.
type PreFetchedValue interface {
Value
NameOf() quad.Value
}
func PreFetched(v quad.Value) PreFetchedValue {
return fetchedValue{v}
}
type fetchedValue struct {
Val quad.Value
}
func (v fetchedValue) IsNode() bool { return true }
func (v fetchedValue) NameOf() quad.Value { return v.Val }
func (v fetchedValue) Key() interface{} { return v.Val }
// Keyer provides a method for comparing types that are not otherwise comparable.
// The Key method must return a dynamic type that is comparable according to the
// Go language specification. The returned value must be unique for each receiver
// value.
//
// Deprecated: Value contains the same method now.
type Keyer interface {
Key() interface{}
}
// ToKey prepares Value to be stored inside maps, calling Key() if necessary.
func ToKey(v Value) interface{} {
if v == nil {
return nil
}
return v.Key()
}
var _ Value = QuadHash{}
type QuadHash struct {
Subject ValueHash
Predicate ValueHash
Object ValueHash
Label ValueHash
}
func (q QuadHash) Dirs() [4]ValueHash {
return [4]ValueHash{
q.Subject,
q.Predicate,
q.Object,
q.Label,
}
}
func (q QuadHash) Key() interface{} { return q }
func (q QuadHash) Get(d quad.Direction) ValueHash {
switch d {
case quad.Subject:
return q.Subject
case quad.Predicate:
return q.Predicate
case quad.Object:
return q.Object
case quad.Label:
return q.Label
}
panic(fmt.Errorf("unknown direction: %v", d))
}
func (q *QuadHash) Set(d quad.Direction, h ValueHash) {
switch d {
case quad.Subject:
q.Subject = h
case quad.Predicate:
q.Predicate = h
case quad.Object:
q.Object = h
case quad.Label:
q.Label = h
default:
panic(fmt.Errorf("unknown direction: %v", d))
}
}