// recurse generated the triple by recursing while there are still triples
// left to generate.
func (t *treeGenerator) recurse(parent *node.Node, left *int, currentDepth, maxDepth int, trpls []*triple.Triple) ([]*triple.Triple, error) {
if *left < 1 {
return trpls, nil
}
for i, last := 0, *left <= t.branch; i < t.branch; i++ {
offspring, err := t.newNode(i, parent.ID().String())
if err != nil {
return trpls, err
}
trpl, err := t.newTriple(parent, offspring)
if err != nil {
return trpls, err
}
trpls = append(trpls, trpl)
(*left)--
if *left < 1 {
break
}
if currentDepth < maxDepth && !last {
ntrpls, err := t.recurse(offspring, left, currentDepth+1, maxDepth, trpls)
if err != nil {
return ntrpls, err
}
trpls = ntrpls
}
if *left < 1 {
break
}
}
return trpls, nil
}
// TriplesForSubject returns all triples available for a given subect.
func (m *memory) TriplesForSubject(s *node.Node, lo *storage.LookupOptions) (storage.Triples, error) {
sGUID := s.GUID()
m.rwmu.RLock()
triples := make(chan *triple.Triple, len(m.idxS[sGUID]))
go func() {
ckr := newChecker(lo)
for _, t := range m.idxS[sGUID] {
if ckr.CheckAndUpdate(t.P()) {
triples <- t
}
}
m.rwmu.RUnlock()
close(triples)
}()
return triples, nil
}
// PredicatesForSubject returns all the predicats know for the given
// subject.
func (m *memory) PredicatesForSubject(s *node.Node, lo *storage.LookupOptions) (storage.Predicates, error) {
sGUID := s.GUID()
m.rwmu.RLock()
preds := make(chan *predicate.Predicate, len(m.idxS[sGUID]))
go func() {
ckr := newChecker(lo)
for _, t := range m.idxS[sGUID] {
if ckr.CheckAndUpdate(t.P()) {
preds <- t.P()
}
}
m.rwmu.RUnlock()
close(preds)
}()
return preds, nil
}
// TriplesForSubjectAndPredicate returns all triples available for the given
// subject and predicate.
func (m *memory) TriplesForSubjectAndPredicate(s *node.Node, p *predicate.Predicate, lo *storage.LookupOptions) (storage.Triples, error) {
sGUID := s.GUID()
pGUID := p.GUID()
spIdx := strings.Join([]string{sGUID, pGUID}, ":")
m.rwmu.RLock()
triples := make(chan *triple.Triple, len(m.idxSP[spIdx]))
go func() {
ckr := newChecker(lo)
for _, t := range m.idxSP[spIdx] {
if ckr.CheckAndUpdate(t.P()) {
triples <- t
}
}
m.rwmu.RUnlock()
close(triples)
}()
return triples, nil
}
// PredicatesForSubjecAndObject returns all predicates available for the
// given subject and object.
func (m *memory) PredicatesForSubjectAndObject(s *node.Node, o *triple.Object, lo *storage.LookupOptions) (storage.Predicates, error) {
sGUID := s.GUID()
oGUID := o.GUID()
soIdx := strings.Join([]string{sGUID, oGUID}, ":")
m.rwmu.RLock()
preds := make(chan *predicate.Predicate, len(m.idxSO[soIdx]))
go func() {
ckr := newChecker(lo)
for _, t := range m.idxSO[soIdx] {
if ckr.CheckAndUpdate(t.P()) {
preds <- t.P()
}
}
m.rwmu.RUnlock()
close(preds)
}()
return preds, nil
}
// Objects returns the objects for the give object and predicate.
func (m *memory) Objects(ctx context.Context, s *node.Node, p *predicate.Predicate, lo *storage.LookupOptions) (storage.Objects, error) {
sGUID := s.GUID()
pGUID := p.GUID()
spIdx := strings.Join([]string{sGUID, pGUID}, ":")
m.rwmu.RLock()
objs := make(chan *triple.Object, len(m.idxSP[spIdx]))
go func() {
ckr := newChecker(lo)
for _, t := range m.idxSP[spIdx] {
if ckr.CheckAndUpdate(t.Predicate()) {
objs <- t.Object()
}
}
m.rwmu.RUnlock()
close(objs)
}()
return objs, nil
}