117 lines
3.3 KiB
Go
117 lines
3.3 KiB
Go
// Copyright 2014 The Cayley Authors. All rights reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package graph
|
|
|
|
// Defines one of the base iterators, the All iterator. Which, logically
|
|
// enough, represents all nodes or all links in the graph.
|
|
//
|
|
// This particular file is actually vestigal. It's up to the TripleStore to give
|
|
// us an All iterator that represents all things in the graph. So this is
|
|
// really the All iterator for the MemTripleStore. That said, it *is* one of
|
|
// the base iterators, and it helps just to see it here.
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// An All iterator across a range of int64 values, from `max` to `min`.
|
|
type Int64AllIterator struct {
|
|
BaseIterator
|
|
max, min int64
|
|
at int64
|
|
}
|
|
|
|
// Creates a new Int64AllIterator with the given range.
|
|
func NewInt64AllIterator(min, max int64) *Int64AllIterator {
|
|
var all Int64AllIterator
|
|
BaseIteratorInit(&all.BaseIterator)
|
|
all.max = max
|
|
all.min = min
|
|
all.at = min
|
|
return &all
|
|
}
|
|
|
|
// Start back at the beginning
|
|
func (a *Int64AllIterator) Reset() {
|
|
a.at = a.min
|
|
}
|
|
|
|
func (a *Int64AllIterator) Close() {
|
|
}
|
|
|
|
func (a *Int64AllIterator) Clone() Iterator {
|
|
out := NewInt64AllIterator(a.min, a.max)
|
|
out.CopyTagsFrom(a)
|
|
return out
|
|
}
|
|
|
|
// Prints the All iterator as just an "all".
|
|
func (a *Int64AllIterator) DebugString(indent int) string {
|
|
return fmt.Sprintf("%s(%s)", strings.Repeat(" ", indent), a.Type())
|
|
}
|
|
|
|
// Next() on an Int64 all iterator is a simple incrementing counter.
|
|
// Return the next integer, and mark it as the result.
|
|
func (a *Int64AllIterator) Next() (TSVal, bool) {
|
|
NextLogIn(a)
|
|
if a.at == -1 {
|
|
return NextLogOut(a, nil, false)
|
|
}
|
|
val := a.at
|
|
a.at = a.at + 1
|
|
if a.at > a.max {
|
|
a.at = -1
|
|
}
|
|
a.Last = val
|
|
return NextLogOut(a, val, true)
|
|
}
|
|
|
|
// The number of elements in an Int64AllIterator is the size of the range.
|
|
// The size is exact.
|
|
func (a *Int64AllIterator) Size() (int64, bool) {
|
|
Size := ((a.max - a.min) + 1)
|
|
return Size, true
|
|
}
|
|
|
|
// Check() for an Int64AllIterator is merely seeing if the passed value is
|
|
// withing the range, assuming the value is an int64.
|
|
func (a *Int64AllIterator) Check(tsv TSVal) bool {
|
|
CheckLogIn(a, tsv)
|
|
v := tsv.(int64)
|
|
if a.min <= v && v <= a.max {
|
|
a.Last = v
|
|
return CheckLogOut(a, v, true)
|
|
}
|
|
return CheckLogOut(a, v, false)
|
|
}
|
|
|
|
// The type of this iterator is an "all". This is important, as it puts it in
|
|
// the class of "all iterators.
|
|
func (a *Int64AllIterator) Type() string { return "all" }
|
|
|
|
// There's nothing to optimize about this little iterator.
|
|
func (a *Int64AllIterator) Optimize() (Iterator, bool) { return a, false }
|
|
|
|
// Stats for an Int64AllIterator are simple. Super cheap to do any operation,
|
|
// and as big as the range.
|
|
func (a *Int64AllIterator) GetStats() *IteratorStats {
|
|
s, _ := a.Size()
|
|
return &IteratorStats{
|
|
CheckCost: 1,
|
|
NextCost: 1,
|
|
Size: s,
|
|
}
|
|
}
|