1// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package android
16
17import (
18	"fmt"
19	"sync"
20)
21
22type OncePer struct {
23	values sync.Map
24}
25
26type onceValueWaiter chan bool
27
28func (once *OncePer) maybeWaitFor(key OnceKey, value interface{}) interface{} {
29	if wait, isWaiter := value.(onceValueWaiter); isWaiter {
30		// The entry in the map is a placeholder waiter because something else is constructing the value
31		// wait until the waiter is signalled, then load the real value.
32		<-wait
33		value, _ = once.values.Load(key)
34		if _, isWaiter := value.(onceValueWaiter); isWaiter {
35			panic(fmt.Errorf("Once() waiter completed but key is still not valid"))
36		}
37	}
38
39	return value
40}
41
42// Once computes a value the first time it is called with a given key per OncePer, and returns the
43// value without recomputing when called with the same key.  key must be hashable.  If value panics
44// the panic will be propagated but the next call to Once with the same key will return nil.
45func (once *OncePer) Once(key OnceKey, value func() interface{}) interface{} {
46	// Fast path: check if the key is already in the map
47	if v, ok := once.values.Load(key); ok {
48		return once.maybeWaitFor(key, v)
49	}
50
51	// Slow path: create a OnceValueWrapper and attempt to insert it
52	waiter := make(onceValueWaiter)
53	if v, loaded := once.values.LoadOrStore(key, waiter); loaded {
54		// Got a value, something else inserted its own waiter or a constructed value
55		return once.maybeWaitFor(key, v)
56	}
57
58	// The waiter is inserted, call the value constructor, store it, and signal the waiter.  Use defer in case
59	// the function panics.
60	var v interface{}
61	defer func() {
62		once.values.Store(key, v)
63		close(waiter)
64	}()
65
66	v = value()
67
68	return v
69}
70
71// Get returns the value previously computed with Once for a given key.  If Once has not been called for the given
72// key Get will panic.
73func (once *OncePer) Get(key OnceKey) interface{} {
74	v, ok := once.values.Load(key)
75	if !ok {
76		panic(fmt.Errorf("Get() called before Once()"))
77	}
78
79	return once.maybeWaitFor(key, v)
80}
81
82// OnceStringSlice is the same as Once, but returns the value cast to a []string
83func (once *OncePer) OnceStringSlice(key OnceKey, value func() []string) []string {
84	return once.Once(key, func() interface{} { return value() }).([]string)
85}
86
87// OnceStringSlice is the same as Once, but returns two values cast to []string
88func (once *OncePer) Once2StringSlice(key OnceKey, value func() ([]string, []string)) ([]string, []string) {
89	type twoStringSlice [2][]string
90	s := once.Once(key, func() interface{} {
91		var s twoStringSlice
92		s[0], s[1] = value()
93		return s
94	}).(twoStringSlice)
95	return s[0], s[1]
96}
97
98// OncePath is the same as Once, but returns the value cast to a Path
99func (once *OncePer) OncePath(key OnceKey, value func() Path) Path {
100	return once.Once(key, func() interface{} { return value() }).(Path)
101}
102
103// OncePath is the same as Once, but returns the value cast to a SourcePath
104func (once *OncePer) OnceSourcePath(key OnceKey, value func() SourcePath) SourcePath {
105	return once.Once(key, func() interface{} { return value() }).(SourcePath)
106}
107
108// OnceKey is an opaque type to be used as the key in calls to Once.
109type OnceKey struct {
110	key interface{}
111}
112
113// NewOnceKey returns an opaque OnceKey object for the provided key.  Two calls to NewOnceKey with the same key string
114// DO NOT produce the same OnceKey object.
115func NewOnceKey(key string) OnceKey {
116	return OnceKey{&key}
117}
118
119// NewCustomOnceKey returns an opaque OnceKey object for the provided key.  The key can be any type that is valid as the
120// key in a map, i.e. comparable.  Two calls to NewCustomOnceKey with key values that compare equal will return OnceKey
121// objects that access the same value stored with Once.
122func NewCustomOnceKey(key interface{}) OnceKey {
123	return OnceKey{key}
124}
125