Documentation ¶
Index ¶
- Constants
- Variables
- func CleanupDir(dir string)
- func CleanupDirs(dirs []string)
- func CreateNTempDirs(t *testing.T, prefix string, n int) []string
- func CreateTempDir(t *testing.T, prefix string) string
- func CreateTestAddr(network string) net.Addr
- func EnsureHost(addr string) string
- func Error(a ...interface{}) error
- func ErrorSkipFrames(skip int, a ...interface{}) error
- func Errorf(format string, a ...interface{}) error
- func ErrorfSkipFrames(skip int, format string, a ...interface{}) error
- func GetContentType(request *http.Request) string
- func IsTrueWithin(trueFunc func() bool, duration time.Duration) error
- func MarshalResponse(r *http.Request, value interface{}, allowed []EncodingType) (body []byte, contentType string, err error)
- func NewPseudoRand() (*rand.Rand, int64)
- func NewPseudoSeed() int64
- func RandBytes(r *rand.Rand, size int) []byte
- func RandIntInRange(r *rand.Rand, min, max int) int
- func RetryWithBackoff(opts RetryOptions, fn func() (RetryStatus, error)) error
- func SucceedsWithin(t testing.TB, duration time.Duration, fn func() error)
- func UnmarshalRequest(r *http.Request, body []byte, value interface{}, allowed []EncodingType) error
- type BuildInfo
- type CacheConfig
- type Closer
- type EncodingType
- type EvictionPolicy
- type Feed
- type IntervalCache
- func (bc IntervalCache) Add(key, value interface{})
- func (bc IntervalCache) Clear()
- func (bc IntervalCache) Del(key interface{})
- func (ic *IntervalCache) Do(f func(k, v interface{}))
- func (bc IntervalCache) Get(key interface{}) (value interface{}, ok bool)
- func (ic *IntervalCache) GetOverlaps(start, end interval.Comparable) []Overlap
- func (bc IntervalCache) Len() int
- func (ic *IntervalCache) NewKey(start, end interval.Comparable) *IntervalKey
- type IntervalKey
- func (ik *IntervalKey) Contains(lk *IntervalKey) bool
- func (ik *IntervalKey) End() interval.Comparable
- func (ik *IntervalKey) Overlap(r interval.Range) bool
- func (ik *IntervalKey) SetEnd(c interval.Comparable)
- func (ik *IntervalKey) SetStart(c interval.Comparable)
- func (ik *IntervalKey) Start() interval.Comparable
- func (ik IntervalKey) String() string
- type Ordered
- type OrderedCache
- func (bc OrderedCache) Add(key, value interface{})
- func (oc *OrderedCache) Ceil(key interface{}) (k, v interface{}, ok bool)
- func (bc OrderedCache) Clear()
- func (bc OrderedCache) Del(key interface{})
- func (oc *OrderedCache) Do(f func(k, v interface{}))
- func (oc *OrderedCache) Floor(key interface{}) (k, v interface{}, ok bool)
- func (bc OrderedCache) Get(key interface{}) (value interface{}, ok bool)
- func (bc OrderedCache) Len() int
- type Overlap
- type RawAddr
- type RetryMaxAttemptsError
- type RetryOptions
- type RetryStatus
- type Retryable
- type Stopper
- func (s *Stopper) AddCloser(c Closer)
- func (s *Stopper) AddWorker()
- func (s *Stopper) FinishTask()
- func (s *Stopper) IsStopped() <-chan struct{}
- func (s *Stopper) Quiesce()
- func (s *Stopper) RunWorker(f func())
- func (s *Stopper) SetStopped()
- func (s *Stopper) ShouldStop() <-chan struct{}
- func (s *Stopper) StartTask() bool
- func (s *Stopper) Stop()
- type Subscription
- type UUID
- type UnorderedCache
- type WeightedReservoirSample
- type WeightedValue
- type WeightedValueHeap
Examples ¶
Constants ¶
const ( // ContentTypeHeader is the canonical header name for content type. ContentTypeHeader = "Content-Type" // AcceptHeader is the canonical header name for accept. AcceptHeader = "Accept" // JSONContentType is the JSON content type. JSONContentType = "application/json" // AltJSONContentType is the alternate JSON content type. AltJSONContentType = "application/x-json" // ProtoContentType is the protobuf content type. ProtoContentType = "application/x-protobuf" // AltProtoContentType is the alternate protobuf content type. AltProtoContentType = "application/x-google-protobuf" // YAMLContentType is the YAML content type. YAMLContentType = "text/yaml" // AltYAMLContentType is the alternate YAML content type. AltYAMLContentType = "application/x-yaml" )
const (
// UUIDSize is the size in bytes of a UUID.
UUIDSize = 16
)
Variables ¶
var AllEncodings = []EncodingType{JSONEncoding, ProtoEncoding, YAMLEncoding}
AllEncodings includes all supported encodings.
Functions ¶
func CleanupDir ¶
func CleanupDir(dir string)
CleanupDir removes the passed-in directory and all contents. Errors are ignored.
func CleanupDirs ¶
func CleanupDirs(dirs []string)
CleanupDirs removes all passed-in directories and their contents.
func CreateNTempDirs ¶
CreateNTempDirs creates N temporary directories and returns a slice of paths. You should usually call defer CleanupDirs(dirs) right after.
func CreateTempDir ¶
CreateTempDir creates a temporary directory and returns its path. You should usually call defer CleanupDir(dir) right after.
func CreateTestAddr ¶
CreateTestAddr creates an unused address for testing. The "network" parameter should be one of "tcp" or "unix".
func EnsureHost ¶
EnsureHost takes a host:port pair, where the host portion is optional. If a host is present, the output is equal to the input. Otherwise, the output will contain a host portion equal to the hostname (or "127.0.0.1" as a fallback).
func Error ¶
func Error(a ...interface{}) error
Error is a passthrough to fmt.Error, with an additional prefix containing the filename and line number.
func ErrorSkipFrames ¶
ErrorSkipFrames allows the skip count for stack frames to be specified. See the comments for ErrorfSkip.
func Errorf ¶
Errorf is a passthrough to fmt.Errorf, with an additional prefix containing the filename and line number.
func ErrorfSkipFrames ¶
ErrorfSkipFrames allows the skip count for stack frames to be specified. This is useful when generating errors via helper methods. Skip should be specified as the number of additional stack frames between the location at which the error is caused and the location at which the error is generated.
func GetContentType ¶
GetContentType pulls out the content type from a request header it ignores every value after the first semicolon
func IsTrueWithin ¶
IsTrueWithin returns an error if the supplied function fails to evaluate to true within the specified duration. The function is invoked immediately at first and then successively with an exponential backoff starting at 1ns and ending at the specified duration.
This method is deprecated; use SucceedsWithin instead. TODO(bdarnell): convert existing uses of IsTrueWithin to SucceedsWithin.
func MarshalResponse ¶
func MarshalResponse(r *http.Request, value interface{}, allowed []EncodingType) ( body []byte, contentType string, err error)
MarshalResponse examines the request Accept header to determine the client's preferred response encoding. Supported content types include JSON, protobuf, and YAML. If the Accept header is not available, the Content-Type header specifying the request encoding is used. The value parameter is marshalled using the response encoding and the resulting body and content type are returned. If the encoding could not be determined by either header, the response is marshalled using JSON. Falls back to JSON when the protobuf format cannot be used for the given value.
func NewPseudoRand ¶
NewPseudoRand returns an instance of math/rand.Rand seeded from crypto/rand and its seed so we can easily and cheaply generate unique streams of numbers. The created object is not safe for concurrent access.
func RandIntInRange ¶
RandIntInRange returns a value in [min, max)
func RetryWithBackoff ¶
func RetryWithBackoff(opts RetryOptions, fn func() (RetryStatus, error)) error
RetryWithBackoff implements retry with exponential backoff using the supplied options as parameters. When fn returns RetryContinue and the number of retry attempts haven't been exhausted, fn is retried. When fn returns RetryBreak, retry ends. As a special case, if fn returns RetryReset, the backoff and retry count are reset to starting values and the next retry occurs immediately. Returns an error if the maximum number of retries is exceeded or if the fn returns an error.
func SucceedsWithin ¶
SucceedsWithin fails the test (with t.Fatal) unless the supplied function runs without error within the specified duration. The function is invoked immediately at first and then successively with an exponential backoff starting at 1ns and ending at the specified duration.
func UnmarshalRequest ¶
func UnmarshalRequest(r *http.Request, body []byte, value interface{}, allowed []EncodingType) error
UnmarshalRequest examines the request Content-Type header in order to determine the encoding of the supplied body. Supported content types include:
JSON - {"application/json", "application/x-json"} Protobuf - {"application/x-protobuf", "application/x-google-protobuf"} YAML - {"text/yaml", "application/x-yaml"}
The body is unmarshalled into the supplied value parameter. An error is returned on an unmarshalling error or on an unsupported content type.
Types ¶
type BuildInfo ¶
type BuildInfo struct { Vers string `json:"goVersion"` Tag string `json:"tag"` Time string `json:"time"` Deps string `json:"dependencies"` }
BuildInfo ...
type CacheConfig ¶
type CacheConfig struct { // Policy is one of the consts listed for EvictionPolicy. Policy EvictionPolicy // ShouldEvict is a callback function executed each time a new entry // is added to the cache. It supplies cache size, and potential // evictee's key and value. The function should return true if the // entry may be evicted; false otherwise. For example, to support a // maximum size for the cache, use a method like: // // func(size int, key Key, value interface{}) { return size > maxSize } // // To support max TTL in the cache, use something like: // // func(size int, key Key, value interface{}) { // return time.Now().UnixNano() - value.(int64) > maxTTLNanos // } ShouldEvict func(size int, key, value interface{}) bool // OnEvicted optionally specifies a callback function to be // executed when an entry is purged from the cache. OnEvicted func(key, value interface{}) }
A CacheConfig specifies the eviction policy, eviction trigger callback, and eviction listener callback.
type Closer ¶
type Closer interface {
Close()
}
Closer is an interface for objects to attach to the stopper to be closed once the stopper completes.
type EncodingType ¶
type EncodingType int
EncodingType is an enum describing available encodings.
const ( // JSONEncoding includes application/json and application/x-json. JSONEncoding EncodingType = iota // ProtoEncoding includes application/x-protobuf and application/x-google-protobuf. ProtoEncoding // YAMLEncoding includes text/yaml and application/x-yaml. YAMLEncoding )
type EvictionPolicy ¶
type EvictionPolicy int
EvictionPolicy is the cache eviction policy enum.
const ( CacheLRU EvictionPolicy = iota // Least recently used CacheFIFO // First in, first out CacheNone // No evictions; don't maintain ordering list )
Constants describing LRU and FIFO, and None cache eviction policies respectively.
type Feed ¶
A Feed is used to publish a stream of events to a set of Subscribers. Events are values of arbitrary type, and are received and published as an empty interface. Each Subscriber will receive, in order, each entry published to the Feed.
Entries are published by via the Publish method of the Feed; this cannot be blocked by Subscriber activities and will always return quickly. Subscribers receive events by reading from their Events channel.
A Feed can be initialized by simply instantiating an empty feed object:
feed := &Feed{} subscriber := feed.Subscribe() feed.Publish(someEvent())
The Feed does not keep historical events; individual Subscribers will only receive events published after they Subscribe. Events can be published to a Feed until its Close() method is called.
The non-blocking property of the feed is achieved by giving each Subscriber's Events channel a very large buffer. If a Subscriber does not read from its channel, then its buffer will fill; if a call to Publish() attempts to write to a full Subscriber channel, it will panic.
Example ¶
stopper := NewStopper() feed := Feed{} output := make([][]string, 5) for i := 0; i < len(output); i++ { sub := feed.Subscribe() index := i stopper.RunWorker(func() { for event := range sub.Events() { // events must be cast from interface{} output[index] = append(output[index], event.(string)) } }) } feed.Publish("Event 1") feed.Publish("Event 2") feed.Publish("Event 3") feed.Close() stopper.Stop() <-stopper.IsStopped() for i, out := range output { fmt.Printf("subscriber %d got output %v\n", i+1, out) }
Output: subscriber 1 got output [Event 1 Event 2 Event 3] subscriber 2 got output [Event 1 Event 2 Event 3] subscriber 3 got output [Event 1 Event 2 Event 3] subscriber 4 got output [Event 1 Event 2 Event 3] subscriber 5 got output [Event 1 Event 2 Event 3]
func (*Feed) Close ¶
func (f *Feed) Close()
Close closes the given Feed. All existing Subscribers will be closed immediately when the Feed is closed. After closure, any new Subscribers will be closed immediately and attempts to Publish will be ignored.
func (*Feed) Publish ¶
func (f *Feed) Publish(event interface{})
Publish publishes a event into the Feed, which will eventually be received by all Subscribers to the feed. Events published to a closed feed, or to a feed with no Subscribers, will be ignored.
func (*Feed) Subscribe ¶
func (f *Feed) Subscribe() *Subscription
Subscribe returns a Subscription object which can immediately recieve events which were published to this feed. An event is an arbitrary interface.
Events are read from the Subscription's Events channel. Subscribers cannot block each other from receiving events, but should still attempt to consume events in a timely fashion; if a Subscriber's (very large) Events channel fills up, a panic may result.
type IntervalCache ¶
type IntervalCache struct {
// contains filtered or unexported fields
}
IntervalCache is a cache which supports querying of intervals which match a key or range of keys. It is backed by an interval tree. See comments in UnorderedCache for more details on cache functionality.
Note that the IntervalCache allow multiple identical segments, as specified by start and end keys.
Keys supplied to the IntervalCache's Get, Add & Del methods must be constructed from IntervalCache.NewKey().
IntervalCache is not safe for concurrent access.
func NewIntervalCache ¶
func NewIntervalCache(config CacheConfig) *IntervalCache
NewIntervalCache creates a new Cache backed by an interval tree. See NewCache() for details on parameters.
func (IntervalCache) Add ¶
func (bc IntervalCache) Add(key, value interface{})
Add adds a value to the cache.
func (IntervalCache) Clear ¶
func (bc IntervalCache) Clear()
Clear clears all entries from the cache.
func (IntervalCache) Del ¶
func (bc IntervalCache) Del(key interface{})
Del removes the provided key from the cache.
func (*IntervalCache) Do ¶
func (ic *IntervalCache) Do(f func(k, v interface{}))
Do invokes f on all of the entries in the cache.
func (IntervalCache) Get ¶
func (bc IntervalCache) Get(key interface{}) (value interface{}, ok bool)
Get looks up a key's value from the cache.
func (*IntervalCache) GetOverlaps ¶
func (ic *IntervalCache) GetOverlaps(start, end interval.Comparable) []Overlap
GetOverlaps returns a slice of values which overlap the specified interval.
func (IntervalCache) Len ¶
func (bc IntervalCache) Len() int
Len returns the number of items in the cache.
func (*IntervalCache) NewKey ¶
func (ic *IntervalCache) NewKey(start, end interval.Comparable) *IntervalKey
NewKey creates a new interval key defined by start and end values.
type IntervalKey ¶
type IntervalKey struct {
// contains filtered or unexported fields
}
IntervalKey provides uniqueness as well as key interval.
func (*IntervalKey) Contains ¶
func (ik *IntervalKey) Contains(lk *IntervalKey) bool
Contains returns true if the specified IntervalKey is contained within this IntervalKey.
func (IntervalKey) String ¶
func (ik IntervalKey) String() string
type Ordered ¶
type Ordered interface { // Returns true if the supplied Ordered value // is less than this object. Less(b Ordered) bool }
Ordered values can be compared against each other.
type OrderedCache ¶
type OrderedCache struct {
// contains filtered or unexported fields
}
OrderedCache is a cache which supports binary searches using Ceil and Floor methods. It is backed by a left-leaning red black tree. See comments in UnorderedCache for more details on cache functionality.
OrderedCache requires that keys implement llrb.Comparable.
OrderedCache is not safe for concurrent access.
func NewOrderedCache ¶
func NewOrderedCache(config CacheConfig) *OrderedCache
NewOrderedCache creates a new Cache backed by a left-leaning red black binary tree which supports binary searches via the Ceil() and Floor() methods. See NewUnorderedCache() for details on parameters.
func (OrderedCache) Add ¶
func (bc OrderedCache) Add(key, value interface{})
Add adds a value to the cache.
func (*OrderedCache) Ceil ¶
func (oc *OrderedCache) Ceil(key interface{}) (k, v interface{}, ok bool)
Ceil returns the smallest cache entry greater than or equal to key.
func (OrderedCache) Del ¶
func (bc OrderedCache) Del(key interface{})
Del removes the provided key from the cache.
func (*OrderedCache) Do ¶
func (oc *OrderedCache) Do(f func(k, v interface{}))
Do invokes f on all of the entries in the cache.
func (*OrderedCache) Floor ¶
func (oc *OrderedCache) Floor(key interface{}) (k, v interface{}, ok bool)
Floor returns the greatest cache entry less than or equal to key.
type Overlap ¶
type Overlap struct { Key *IntervalKey Value interface{} }
Overlap contains the key/value pair for one overlap instance.
type RawAddr ¶
type RawAddr struct { // These fields are only exported so that gob can see them. NetworkField string StringField string }
RawAddr is a super-simple implementation of net.Addr.
func MakeRawAddr ¶
MakeRawAddr creates a new RawAddr from a network and raw address string.
type RetryMaxAttemptsError ¶
type RetryMaxAttemptsError struct {
MaxAttempts int
}
RetryMaxAttemptsError indicates max attempts were exceeded.
func (*RetryMaxAttemptsError) Error ¶
func (re *RetryMaxAttemptsError) Error() string
Error implements error interface.
type RetryOptions ¶
type RetryOptions struct { Tag string // Tag for helpful logging of backoffs Backoff time.Duration // Default retry backoff interval MaxBackoff time.Duration // Maximum retry backoff interval Constant float64 // Default backoff constant MaxAttempts int // Maximum number of attempts (0 for infinite) UseV1Info bool // Use verbose V(1) level for log messages Stopper *Stopper // Optionally end retry loop on stopper signal }
RetryOptions provides control of retry loop logic via the RetryWithBackoffOptions method.
type RetryStatus ¶
type RetryStatus int32
RetryStatus is an enum describing the possible statuses of a backoff / retry worker function.
const ( // RetryBreak indicates the retry loop is finished and should return // the result of the retry worker function. RetryBreak RetryStatus = iota // RetryReset indicates that the retry loop should be reset with // no backoff for an immediate retry. RetryReset // RetryContinue indicates that the retry loop should continue with // another iteration of backoff / retry. RetryContinue )
type Retryable ¶
type Retryable interface {
CanRetry() bool
}
Retryable is an interface for conditions which may be retried.
type Stopper ¶
type Stopper struct {
// contains filtered or unexported fields
}
A Stopper provides a channel-based mechanism to stop an arbitrary array of workers. Each worker is registered with the stopper via the AddWorker() method. The system further tracks each task which is outstanding by calling StartTask() when a task is started and FinishTask() when completed.
Stopping occurs in two phases: the first is the request to stop, which moves the stopper into a draining phase. While draining, calls to StartTask() return false, meaning the system is draining and new tasks should not be accepted. When all outstanding tasks have been completed via calls to FinishTask(), the stopper closes its stopper channel, which signals all live workers that it's safe to shut down. Once shutdown, each worker invokes SetStopped(). When all workers have shutdown, the stopper is complete.
An arbitrary list of objects implementing the Closer interface may be added to the stopper via AddCloser(), to be closed after the stopper has stopped.
func (*Stopper) FinishTask ¶
func (s *Stopper) FinishTask()
FinishTask removes one from the count of tasks left to drain in the system. This function must be invoked for every call to StartTask().
func (*Stopper) IsStopped ¶
func (s *Stopper) IsStopped() <-chan struct{}
IsStopped returns a channel which will be closed after Stop() has been invoked to full completion, meaning all workers have completed and all closers have been closed.
func (*Stopper) Quiesce ¶
func (s *Stopper) Quiesce()
Quiesce moves the stopper to state draining, waits until all tasks complete, then moves back to non-draining state. This is used from unittests.
func (*Stopper) RunWorker ¶
func (s *Stopper) RunWorker(f func())
RunWorker runs the supplied function as a "worker" to be stopped by the stopper. The function <f> is run in a goroutine.
func (*Stopper) SetStopped ¶
func (s *Stopper) SetStopped()
SetStopped should be called after the ShouldStop() channel has been closed to confirm the worker has stopped.
func (*Stopper) ShouldStop ¶
func (s *Stopper) ShouldStop() <-chan struct{}
ShouldStop returns a channel which will be closed when Stop() has been invoked. SetStopped() should be called to confirm.
func (*Stopper) StartTask ¶
StartTask adds one to the count of tasks left to drain in the system. Any worker which is a "first mover" when starting tasks must call this method before starting work on a new task and must subsequently invoke FinishTask() when the task is complete. First movers include goroutines launched to do periodic work and the kv/db.go gateway which accepts external client requests.
Returns true if the task can be launched or false to indicate the system is currently draining and the task should be refused.
type Subscription ¶
type Subscription struct {
// contains filtered or unexported fields
}
A Subscription is used to receive events from a specific Feed. A Subscription should only be instantiated via a call to a Feed's Subscribe() method. Once created, events can be read directly from the Events channel provided by this structure.
An example of a typical usage of a Subscription:
subscriber := feed.Subscribe() for event := range subscriber.Events() { // Process event... }
A Subscription cannot block other Subscriptions to the same feed, and each Subscription will receive all events published by the Feed. The user of a Subscription should not modify Events received over the channel.
A Subscription can be closed via the Unsubscribe() method, which will result in the Events channel being closed. The Events channel will also be closed if the Feed itself is closed.
func (*Subscription) Events ¶
func (s *Subscription) Events() <-chan interface{}
Events returns a recieve only channel for reading events from this Subscriber.
func (*Subscription) Unsubscribe ¶
func (s *Subscription) Unsubscribe()
Unsubscribe stops the Subscriber. This will close the Subscriber's Events channel; however, there may still be unprocessed Events remaining in the channel.
type UUID ¶
type UUID []byte
UUID is a 16 byte UUID.
type UnorderedCache ¶
type UnorderedCache struct {
// contains filtered or unexported fields
}
UnorderedCache is a cache which supports custom eviction triggers and two eviction policies: LRU and FIFO. A listener pattern is available for eviction events. This cache uses a hashmap for storing elements, making it the most performant. Only exact lookups are supported.
UnorderedCache requires that keys are comparable, according to the go specification (http://golang.org/ref/spec#Comparison_operators).
UnorderedCache is not safe for concurrent access.
func NewUnorderedCache ¶
func NewUnorderedCache(config CacheConfig) *UnorderedCache
NewUnorderedCache creates a new UnorderedCache backed by a hash map.
func (UnorderedCache) Add ¶
func (bc UnorderedCache) Add(key, value interface{})
Add adds a value to the cache.
func (UnorderedCache) Clear ¶
func (bc UnorderedCache) Clear()
Clear clears all entries from the cache.
func (UnorderedCache) Del ¶
func (bc UnorderedCache) Del(key interface{})
Del removes the provided key from the cache.
type WeightedReservoirSample ¶
type WeightedReservoirSample struct { Heap heap.Interface // contains filtered or unexported fields }
A WeightedReservoirSample implements the weighted reservoir sampling algorithm as proposed by Efraimidis-Spirakis (2005).
func NewWeightedReservoirSample ¶
func NewWeightedReservoirSample(size int, minHeap heap.Interface) *WeightedReservoirSample
NewWeightedReservoirSample creates a new reservoir sample on the given heap. If minHeap is nil, an in-memory heap is created and used.
func (*WeightedReservoirSample) Consider ¶
func (rs *WeightedReservoirSample) Consider(value interface{})
Consider offers a new value to the underlying reservoir using weight one. Using the same weight for all values considered throughout the lifetime of a sample is equivalent to a non-weighted reservoir sampling algorithm.
func (*WeightedReservoirSample) ConsiderWeighted ¶
func (rs *WeightedReservoirSample) ConsiderWeighted(value interface{}, weight float64)
ConsiderWeighted lets the sample inspect a new value with a positive given weight. A weight of one corresponds to the unweighted reservoir sampling algorithm. A nonpositive weight will lead to the item being rejected without having been observed. To avoid numerical instabilities, it is advisable to stay away from zero and infinity, or more generally from regions in which computing x**1/weight may be ill-behaved.
type WeightedValue ¶
type WeightedValue struct { Value interface{} // contains filtered or unexported fields }
A WeightedValue is used to represent the items sampled by WeightedReservoirSample.
func (WeightedValue) Less ¶
func (wv WeightedValue) Less(zv WeightedValue) bool
Less implements the Ordered interface.
type WeightedValueHeap ¶
type WeightedValueHeap []WeightedValue
A WeightedValueHeap implements a heap structure on a slice of weighted values for use in in-memory weighted reservoir sampling.
func (WeightedValueHeap) Len ¶
func (h WeightedValueHeap) Len() int
Len, Less and Swap implement sort.Interface.
func (WeightedValueHeap) Less ¶
func (h WeightedValueHeap) Less(i, j int) bool
func (*WeightedValueHeap) Pop ¶
func (h *WeightedValueHeap) Pop() interface{}
Pop removes the last element of the slice.
func (*WeightedValueHeap) Push ¶
func (h *WeightedValueHeap) Push(x interface{})
Push appends an element to the slice.
func (WeightedValueHeap) Swap ¶
func (h WeightedValueHeap) Swap(i, j int)
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
Package hlc implements the Hybrid Logical Clock outlined in "Logical Physical Clocks and Consistent Snapshots in Globally Distributed Databases", available online at http://www.cse.buffalo.edu/tech-reports/2014-04.pdf.
|
Package hlc implements the Hybrid Logical Clock outlined in "Logical Physical Clocks and Consistent Snapshots in Globally Distributed Databases", available online at http://www.cse.buffalo.edu/tech-reports/2014-04.pdf. |
Package leaktest provides tools to detect leaked goroutines in tests.
|
Package leaktest provides tools to detect leaked goroutines in tests. |