id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
148,000 |
coocood/freecache
|
cache.go
|
Get
|
func (cache *Cache) Get(key []byte) (value []byte, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
value, _, err = cache.segments[segID].get(key, nil, hashVal)
cache.locks[segID].Unlock()
return
}
|
go
|
func (cache *Cache) Get(key []byte) (value []byte, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
value, _, err = cache.segments[segID].get(key, nil, hashVal)
cache.locks[segID].Unlock()
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"Get",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"hashVal",
":=",
"hashFunc",
"(",
"key",
")",
"\n",
"segID",
":=",
"hashVal",
"&",
"segmentAndOpVal",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Lock",
"(",
")",
"\n",
"value",
",",
"_",
",",
"err",
"=",
"cache",
".",
"segments",
"[",
"segID",
"]",
".",
"get",
"(",
"key",
",",
"nil",
",",
"hashVal",
")",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// Get returns the value or not found error.
|
[
"Get",
"returns",
"the",
"value",
"or",
"not",
"found",
"error",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L59-L66
|
148,001 |
coocood/freecache
|
cache.go
|
GetWithExpiration
|
func (cache *Cache) GetWithExpiration(key []byte) (value []byte, expireAt uint32, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
value, expireAt, err = cache.segments[segID].get(key, nil, hashVal)
cache.locks[segID].Unlock()
return
}
|
go
|
func (cache *Cache) GetWithExpiration(key []byte) (value []byte, expireAt uint32, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
value, expireAt, err = cache.segments[segID].get(key, nil, hashVal)
cache.locks[segID].Unlock()
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"GetWithExpiration",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"expireAt",
"uint32",
",",
"err",
"error",
")",
"{",
"hashVal",
":=",
"hashFunc",
"(",
"key",
")",
"\n",
"segID",
":=",
"hashVal",
"&",
"segmentAndOpVal",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Lock",
"(",
")",
"\n",
"value",
",",
"expireAt",
",",
"err",
"=",
"cache",
".",
"segments",
"[",
"segID",
"]",
".",
"get",
"(",
"key",
",",
"nil",
",",
"hashVal",
")",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// GetWithExpiration returns the value with expiration or not found error.
|
[
"GetWithExpiration",
"returns",
"the",
"value",
"with",
"expiration",
"or",
"not",
"found",
"error",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L80-L87
|
148,002 |
coocood/freecache
|
cache.go
|
TTL
|
func (cache *Cache) TTL(key []byte) (timeLeft uint32, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
timeLeft, err = cache.segments[segID].ttl(key, hashVal)
cache.locks[segID].Unlock()
return
}
|
go
|
func (cache *Cache) TTL(key []byte) (timeLeft uint32, err error) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
timeLeft, err = cache.segments[segID].ttl(key, hashVal)
cache.locks[segID].Unlock()
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"TTL",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"timeLeft",
"uint32",
",",
"err",
"error",
")",
"{",
"hashVal",
":=",
"hashFunc",
"(",
"key",
")",
"\n",
"segID",
":=",
"hashVal",
"&",
"segmentAndOpVal",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Lock",
"(",
")",
"\n",
"timeLeft",
",",
"err",
"=",
"cache",
".",
"segments",
"[",
"segID",
"]",
".",
"ttl",
"(",
"key",
",",
"hashVal",
")",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// TTL returns the TTL time left for a given key or a not found error.
|
[
"TTL",
"returns",
"the",
"TTL",
"time",
"left",
"for",
"a",
"given",
"key",
"or",
"a",
"not",
"found",
"error",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L90-L97
|
148,003 |
coocood/freecache
|
cache.go
|
Del
|
func (cache *Cache) Del(key []byte) (affected bool) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
affected = cache.segments[segID].del(key, hashVal)
cache.locks[segID].Unlock()
return
}
|
go
|
func (cache *Cache) Del(key []byte) (affected bool) {
hashVal := hashFunc(key)
segID := hashVal & segmentAndOpVal
cache.locks[segID].Lock()
affected = cache.segments[segID].del(key, hashVal)
cache.locks[segID].Unlock()
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"Del",
"(",
"key",
"[",
"]",
"byte",
")",
"(",
"affected",
"bool",
")",
"{",
"hashVal",
":=",
"hashFunc",
"(",
"key",
")",
"\n",
"segID",
":=",
"hashVal",
"&",
"segmentAndOpVal",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Lock",
"(",
")",
"\n",
"affected",
"=",
"cache",
".",
"segments",
"[",
"segID",
"]",
".",
"del",
"(",
"key",
",",
"hashVal",
")",
"\n",
"cache",
".",
"locks",
"[",
"segID",
"]",
".",
"Unlock",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// Del deletes an item in the cache by key and returns true or false if a delete occurred.
|
[
"Del",
"deletes",
"an",
"item",
"in",
"the",
"cache",
"by",
"key",
"and",
"returns",
"true",
"or",
"false",
"if",
"a",
"delete",
"occurred",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L100-L107
|
148,004 |
coocood/freecache
|
cache.go
|
SetInt
|
func (cache *Cache) SetInt(key int64, value []byte, expireSeconds int) (err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Set(bKey[:], value, expireSeconds)
}
|
go
|
func (cache *Cache) SetInt(key int64, value []byte, expireSeconds int) (err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Set(bKey[:], value, expireSeconds)
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"SetInt",
"(",
"key",
"int64",
",",
"value",
"[",
"]",
"byte",
",",
"expireSeconds",
"int",
")",
"(",
"err",
"error",
")",
"{",
"var",
"bKey",
"[",
"8",
"]",
"byte",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"bKey",
"[",
":",
"]",
",",
"uint64",
"(",
"key",
")",
")",
"\n",
"return",
"cache",
".",
"Set",
"(",
"bKey",
"[",
":",
"]",
",",
"value",
",",
"expireSeconds",
")",
"\n",
"}"
] |
// SetInt stores in integer value in the cache.
|
[
"SetInt",
"stores",
"in",
"integer",
"value",
"in",
"the",
"cache",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L110-L114
|
148,005 |
coocood/freecache
|
cache.go
|
GetInt
|
func (cache *Cache) GetInt(key int64) (value []byte, err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Get(bKey[:])
}
|
go
|
func (cache *Cache) GetInt(key int64) (value []byte, err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Get(bKey[:])
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"GetInt",
"(",
"key",
"int64",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"var",
"bKey",
"[",
"8",
"]",
"byte",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"bKey",
"[",
":",
"]",
",",
"uint64",
"(",
"key",
")",
")",
"\n",
"return",
"cache",
".",
"Get",
"(",
"bKey",
"[",
":",
"]",
")",
"\n",
"}"
] |
// GetInt returns the value for an integer within the cache or a not found error.
|
[
"GetInt",
"returns",
"the",
"value",
"for",
"an",
"integer",
"within",
"the",
"cache",
"or",
"a",
"not",
"found",
"error",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L117-L121
|
148,006 |
coocood/freecache
|
cache.go
|
GetIntWithExpiration
|
func (cache *Cache) GetIntWithExpiration(key int64) (value []byte, expireAt uint32, err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.GetWithExpiration(bKey[:])
}
|
go
|
func (cache *Cache) GetIntWithExpiration(key int64) (value []byte, expireAt uint32, err error) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.GetWithExpiration(bKey[:])
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"GetIntWithExpiration",
"(",
"key",
"int64",
")",
"(",
"value",
"[",
"]",
"byte",
",",
"expireAt",
"uint32",
",",
"err",
"error",
")",
"{",
"var",
"bKey",
"[",
"8",
"]",
"byte",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"bKey",
"[",
":",
"]",
",",
"uint64",
"(",
"key",
")",
")",
"\n",
"return",
"cache",
".",
"GetWithExpiration",
"(",
"bKey",
"[",
":",
"]",
")",
"\n",
"}"
] |
// GetIntWithExpiration returns the value and expiration or a not found error.
|
[
"GetIntWithExpiration",
"returns",
"the",
"value",
"and",
"expiration",
"or",
"a",
"not",
"found",
"error",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L124-L128
|
148,007 |
coocood/freecache
|
cache.go
|
DelInt
|
func (cache *Cache) DelInt(key int64) (affected bool) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Del(bKey[:])
}
|
go
|
func (cache *Cache) DelInt(key int64) (affected bool) {
var bKey [8]byte
binary.LittleEndian.PutUint64(bKey[:], uint64(key))
return cache.Del(bKey[:])
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"DelInt",
"(",
"key",
"int64",
")",
"(",
"affected",
"bool",
")",
"{",
"var",
"bKey",
"[",
"8",
"]",
"byte",
"\n",
"binary",
".",
"LittleEndian",
".",
"PutUint64",
"(",
"bKey",
"[",
":",
"]",
",",
"uint64",
"(",
"key",
")",
")",
"\n",
"return",
"cache",
".",
"Del",
"(",
"bKey",
"[",
":",
"]",
")",
"\n",
"}"
] |
// DelInt deletes an item in the cache by int key and returns true or false if a delete occurred.
|
[
"DelInt",
"deletes",
"an",
"item",
"in",
"the",
"cache",
"by",
"int",
"key",
"and",
"returns",
"true",
"or",
"false",
"if",
"a",
"delete",
"occurred",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L131-L135
|
148,008 |
coocood/freecache
|
cache.go
|
EvacuateCount
|
func (cache *Cache) EvacuateCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].totalEvacuate)
}
return
}
|
go
|
func (cache *Cache) EvacuateCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].totalEvacuate)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"EvacuateCount",
"(",
")",
"(",
"count",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"count",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"totalEvacuate",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// EvacuateCount is a metric indicating the number of times an eviction occurred.
|
[
"EvacuateCount",
"is",
"a",
"metric",
"indicating",
"the",
"number",
"of",
"times",
"an",
"eviction",
"occurred",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L138-L143
|
148,009 |
coocood/freecache
|
cache.go
|
ExpiredCount
|
func (cache *Cache) ExpiredCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].totalExpired)
}
return
}
|
go
|
func (cache *Cache) ExpiredCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].totalExpired)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"ExpiredCount",
"(",
")",
"(",
"count",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"count",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"totalExpired",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// ExpiredCount is a metric indicating the number of times an expire occurred.
|
[
"ExpiredCount",
"is",
"a",
"metric",
"indicating",
"the",
"number",
"of",
"times",
"an",
"expire",
"occurred",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L146-L151
|
148,010 |
coocood/freecache
|
cache.go
|
EntryCount
|
func (cache *Cache) EntryCount() (entryCount int64) {
for i := range cache.segments {
entryCount += atomic.LoadInt64(&cache.segments[i].entryCount)
}
return
}
|
go
|
func (cache *Cache) EntryCount() (entryCount int64) {
for i := range cache.segments {
entryCount += atomic.LoadInt64(&cache.segments[i].entryCount)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"EntryCount",
"(",
")",
"(",
"entryCount",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"entryCount",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"entryCount",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// EntryCount returns the number of items currently in the cache.
|
[
"EntryCount",
"returns",
"the",
"number",
"of",
"items",
"currently",
"in",
"the",
"cache",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L154-L159
|
148,011 |
coocood/freecache
|
cache.go
|
AverageAccessTime
|
func (cache *Cache) AverageAccessTime() int64 {
var entryCount, totalTime int64
for i := range cache.segments {
totalTime += atomic.LoadInt64(&cache.segments[i].totalTime)
entryCount += atomic.LoadInt64(&cache.segments[i].totalCount)
}
if entryCount == 0 {
return 0
} else {
return totalTime / entryCount
}
}
|
go
|
func (cache *Cache) AverageAccessTime() int64 {
var entryCount, totalTime int64
for i := range cache.segments {
totalTime += atomic.LoadInt64(&cache.segments[i].totalTime)
entryCount += atomic.LoadInt64(&cache.segments[i].totalCount)
}
if entryCount == 0 {
return 0
} else {
return totalTime / entryCount
}
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"AverageAccessTime",
"(",
")",
"int64",
"{",
"var",
"entryCount",
",",
"totalTime",
"int64",
"\n",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"totalTime",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"totalTime",
")",
"\n",
"entryCount",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"totalCount",
")",
"\n",
"}",
"\n",
"if",
"entryCount",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"else",
"{",
"return",
"totalTime",
"/",
"entryCount",
"\n",
"}",
"\n",
"}"
] |
// AverageAccessTime returns the average unix timestamp when a entry being accessed.
// Entries have greater access time will be evacuated when it
// is about to be overwritten by new value.
|
[
"AverageAccessTime",
"returns",
"the",
"average",
"unix",
"timestamp",
"when",
"a",
"entry",
"being",
"accessed",
".",
"Entries",
"have",
"greater",
"access",
"time",
"will",
"be",
"evacuated",
"when",
"it",
"is",
"about",
"to",
"be",
"overwritten",
"by",
"new",
"value",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L164-L175
|
148,012 |
coocood/freecache
|
cache.go
|
HitCount
|
func (cache *Cache) HitCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].hitCount)
}
return
}
|
go
|
func (cache *Cache) HitCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].hitCount)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"HitCount",
"(",
")",
"(",
"count",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"count",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"hitCount",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// HitCount is a metric that returns number of times a key was found in the cache.
|
[
"HitCount",
"is",
"a",
"metric",
"that",
"returns",
"number",
"of",
"times",
"a",
"key",
"was",
"found",
"in",
"the",
"cache",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L178-L183
|
148,013 |
coocood/freecache
|
cache.go
|
MissCount
|
func (cache *Cache) MissCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].missCount)
}
return
}
|
go
|
func (cache *Cache) MissCount() (count int64) {
for i := range cache.segments {
count += atomic.LoadInt64(&cache.segments[i].missCount)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"MissCount",
"(",
")",
"(",
"count",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"count",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"missCount",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// MissCount is a metric that returns the number of times a miss occurred in the cache.
|
[
"MissCount",
"is",
"a",
"metric",
"that",
"returns",
"the",
"number",
"of",
"times",
"a",
"miss",
"occurred",
"in",
"the",
"cache",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L186-L191
|
148,014 |
coocood/freecache
|
cache.go
|
HitRate
|
func (cache *Cache) HitRate() float64 {
hitCount, missCount := cache.HitCount(), cache.MissCount()
lookupCount := hitCount + missCount
if lookupCount == 0 {
return 0
} else {
return float64(hitCount) / float64(lookupCount)
}
}
|
go
|
func (cache *Cache) HitRate() float64 {
hitCount, missCount := cache.HitCount(), cache.MissCount()
lookupCount := hitCount + missCount
if lookupCount == 0 {
return 0
} else {
return float64(hitCount) / float64(lookupCount)
}
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"HitRate",
"(",
")",
"float64",
"{",
"hitCount",
",",
"missCount",
":=",
"cache",
".",
"HitCount",
"(",
")",
",",
"cache",
".",
"MissCount",
"(",
")",
"\n",
"lookupCount",
":=",
"hitCount",
"+",
"missCount",
"\n",
"if",
"lookupCount",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"else",
"{",
"return",
"float64",
"(",
"hitCount",
")",
"/",
"float64",
"(",
"lookupCount",
")",
"\n",
"}",
"\n",
"}"
] |
// HitRate is the ratio of hits over lookups.
|
[
"HitRate",
"is",
"the",
"ratio",
"of",
"hits",
"over",
"lookups",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L199-L207
|
148,015 |
coocood/freecache
|
cache.go
|
OverwriteCount
|
func (cache *Cache) OverwriteCount() (overwriteCount int64) {
for i := range cache.segments {
overwriteCount += atomic.LoadInt64(&cache.segments[i].overwrites)
}
return
}
|
go
|
func (cache *Cache) OverwriteCount() (overwriteCount int64) {
for i := range cache.segments {
overwriteCount += atomic.LoadInt64(&cache.segments[i].overwrites)
}
return
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"OverwriteCount",
"(",
")",
"(",
"overwriteCount",
"int64",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"overwriteCount",
"+=",
"atomic",
".",
"LoadInt64",
"(",
"&",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"overwrites",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// OverwriteCount indicates the number of times entries have been overriden.
|
[
"OverwriteCount",
"indicates",
"the",
"number",
"of",
"times",
"entries",
"have",
"been",
"overriden",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L210-L215
|
148,016 |
coocood/freecache
|
cache.go
|
ResetStatistics
|
func (cache *Cache) ResetStatistics() {
for i := range cache.segments {
cache.locks[i].Lock()
cache.segments[i].resetStatistics()
cache.locks[i].Unlock()
}
}
|
go
|
func (cache *Cache) ResetStatistics() {
for i := range cache.segments {
cache.locks[i].Lock()
cache.segments[i].resetStatistics()
cache.locks[i].Unlock()
}
}
|
[
"func",
"(",
"cache",
"*",
"Cache",
")",
"ResetStatistics",
"(",
")",
"{",
"for",
"i",
":=",
"range",
"cache",
".",
"segments",
"{",
"cache",
".",
"locks",
"[",
"i",
"]",
".",
"Lock",
"(",
")",
"\n",
"cache",
".",
"segments",
"[",
"i",
"]",
".",
"resetStatistics",
"(",
")",
"\n",
"cache",
".",
"locks",
"[",
"i",
"]",
".",
"Unlock",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
// ResetStatistics refreshes the current state of the statistics.
|
[
"ResetStatistics",
"refreshes",
"the",
"current",
"state",
"of",
"the",
"statistics",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/cache.go#L227-L233
|
148,017 |
coocood/freecache
|
ringbuf.go
|
Dump
|
func (rb *RingBuf) Dump() []byte {
dump := make([]byte, len(rb.data))
copy(dump, rb.data)
return dump
}
|
go
|
func (rb *RingBuf) Dump() []byte {
dump := make([]byte, len(rb.data))
copy(dump, rb.data)
return dump
}
|
[
"func",
"(",
"rb",
"*",
"RingBuf",
")",
"Dump",
"(",
")",
"[",
"]",
"byte",
"{",
"dump",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"len",
"(",
"rb",
".",
"data",
")",
")",
"\n",
"copy",
"(",
"dump",
",",
"rb",
".",
"data",
")",
"\n",
"return",
"dump",
"\n",
"}"
] |
// Create a copy of the buffer.
|
[
"Create",
"a",
"copy",
"of",
"the",
"buffer",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/ringbuf.go#L31-L35
|
148,018 |
coocood/freecache
|
ringbuf.go
|
Evacuate
|
func (rb *RingBuf) Evacuate(off int64, length int) (newOff int64) {
if off+int64(length) > rb.end || off < rb.begin {
return -1
}
var readOff int
if rb.end-rb.begin < int64(len(rb.data)) {
readOff = int(off - rb.begin)
} else {
readOff = rb.index + int(off-rb.begin)
}
if readOff >= len(rb.data) {
readOff -= len(rb.data)
}
if readOff == rb.index {
// no copy evacuate
rb.index += length
if rb.index >= len(rb.data) {
rb.index -= len(rb.data)
}
} else if readOff < rb.index {
var n = copy(rb.data[rb.index:], rb.data[readOff:readOff+length])
rb.index += n
if rb.index == len(rb.data) {
rb.index = copy(rb.data, rb.data[readOff+n:readOff+length])
}
} else {
var readEnd = readOff + length
var n int
if readEnd <= len(rb.data) {
n = copy(rb.data[rb.index:], rb.data[readOff:readEnd])
rb.index += n
} else {
n = copy(rb.data[rb.index:], rb.data[readOff:])
rb.index += n
var tail = length - n
n = copy(rb.data[rb.index:], rb.data[:tail])
rb.index += n
if rb.index == len(rb.data) {
rb.index = copy(rb.data, rb.data[n:tail])
}
}
}
newOff = rb.end
rb.end += int64(length)
if rb.begin < rb.end-int64(len(rb.data)) {
rb.begin = rb.end - int64(len(rb.data))
}
return
}
|
go
|
func (rb *RingBuf) Evacuate(off int64, length int) (newOff int64) {
if off+int64(length) > rb.end || off < rb.begin {
return -1
}
var readOff int
if rb.end-rb.begin < int64(len(rb.data)) {
readOff = int(off - rb.begin)
} else {
readOff = rb.index + int(off-rb.begin)
}
if readOff >= len(rb.data) {
readOff -= len(rb.data)
}
if readOff == rb.index {
// no copy evacuate
rb.index += length
if rb.index >= len(rb.data) {
rb.index -= len(rb.data)
}
} else if readOff < rb.index {
var n = copy(rb.data[rb.index:], rb.data[readOff:readOff+length])
rb.index += n
if rb.index == len(rb.data) {
rb.index = copy(rb.data, rb.data[readOff+n:readOff+length])
}
} else {
var readEnd = readOff + length
var n int
if readEnd <= len(rb.data) {
n = copy(rb.data[rb.index:], rb.data[readOff:readEnd])
rb.index += n
} else {
n = copy(rb.data[rb.index:], rb.data[readOff:])
rb.index += n
var tail = length - n
n = copy(rb.data[rb.index:], rb.data[:tail])
rb.index += n
if rb.index == len(rb.data) {
rb.index = copy(rb.data, rb.data[n:tail])
}
}
}
newOff = rb.end
rb.end += int64(length)
if rb.begin < rb.end-int64(len(rb.data)) {
rb.begin = rb.end - int64(len(rb.data))
}
return
}
|
[
"func",
"(",
"rb",
"*",
"RingBuf",
")",
"Evacuate",
"(",
"off",
"int64",
",",
"length",
"int",
")",
"(",
"newOff",
"int64",
")",
"{",
"if",
"off",
"+",
"int64",
"(",
"length",
")",
">",
"rb",
".",
"end",
"||",
"off",
"<",
"rb",
".",
"begin",
"{",
"return",
"-",
"1",
"\n",
"}",
"\n",
"var",
"readOff",
"int",
"\n",
"if",
"rb",
".",
"end",
"-",
"rb",
".",
"begin",
"<",
"int64",
"(",
"len",
"(",
"rb",
".",
"data",
")",
")",
"{",
"readOff",
"=",
"int",
"(",
"off",
"-",
"rb",
".",
"begin",
")",
"\n",
"}",
"else",
"{",
"readOff",
"=",
"rb",
".",
"index",
"+",
"int",
"(",
"off",
"-",
"rb",
".",
"begin",
")",
"\n",
"}",
"\n",
"if",
"readOff",
">=",
"len",
"(",
"rb",
".",
"data",
")",
"{",
"readOff",
"-=",
"len",
"(",
"rb",
".",
"data",
")",
"\n",
"}",
"\n\n",
"if",
"readOff",
"==",
"rb",
".",
"index",
"{",
"// no copy evacuate",
"rb",
".",
"index",
"+=",
"length",
"\n",
"if",
"rb",
".",
"index",
">=",
"len",
"(",
"rb",
".",
"data",
")",
"{",
"rb",
".",
"index",
"-=",
"len",
"(",
"rb",
".",
"data",
")",
"\n",
"}",
"\n",
"}",
"else",
"if",
"readOff",
"<",
"rb",
".",
"index",
"{",
"var",
"n",
"=",
"copy",
"(",
"rb",
".",
"data",
"[",
"rb",
".",
"index",
":",
"]",
",",
"rb",
".",
"data",
"[",
"readOff",
":",
"readOff",
"+",
"length",
"]",
")",
"\n",
"rb",
".",
"index",
"+=",
"n",
"\n",
"if",
"rb",
".",
"index",
"==",
"len",
"(",
"rb",
".",
"data",
")",
"{",
"rb",
".",
"index",
"=",
"copy",
"(",
"rb",
".",
"data",
",",
"rb",
".",
"data",
"[",
"readOff",
"+",
"n",
":",
"readOff",
"+",
"length",
"]",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"var",
"readEnd",
"=",
"readOff",
"+",
"length",
"\n",
"var",
"n",
"int",
"\n",
"if",
"readEnd",
"<=",
"len",
"(",
"rb",
".",
"data",
")",
"{",
"n",
"=",
"copy",
"(",
"rb",
".",
"data",
"[",
"rb",
".",
"index",
":",
"]",
",",
"rb",
".",
"data",
"[",
"readOff",
":",
"readEnd",
"]",
")",
"\n",
"rb",
".",
"index",
"+=",
"n",
"\n",
"}",
"else",
"{",
"n",
"=",
"copy",
"(",
"rb",
".",
"data",
"[",
"rb",
".",
"index",
":",
"]",
",",
"rb",
".",
"data",
"[",
"readOff",
":",
"]",
")",
"\n",
"rb",
".",
"index",
"+=",
"n",
"\n",
"var",
"tail",
"=",
"length",
"-",
"n",
"\n",
"n",
"=",
"copy",
"(",
"rb",
".",
"data",
"[",
"rb",
".",
"index",
":",
"]",
",",
"rb",
".",
"data",
"[",
":",
"tail",
"]",
")",
"\n",
"rb",
".",
"index",
"+=",
"n",
"\n",
"if",
"rb",
".",
"index",
"==",
"len",
"(",
"rb",
".",
"data",
")",
"{",
"rb",
".",
"index",
"=",
"copy",
"(",
"rb",
".",
"data",
",",
"rb",
".",
"data",
"[",
"n",
":",
"tail",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"newOff",
"=",
"rb",
".",
"end",
"\n",
"rb",
".",
"end",
"+=",
"int64",
"(",
"length",
")",
"\n",
"if",
"rb",
".",
"begin",
"<",
"rb",
".",
"end",
"-",
"int64",
"(",
"len",
"(",
"rb",
".",
"data",
")",
")",
"{",
"rb",
".",
"begin",
"=",
"rb",
".",
"end",
"-",
"int64",
"(",
"len",
"(",
"rb",
".",
"data",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Evacuate read the data at off, then write it to the the data stream,
// Keep it from being overwritten by new data.
|
[
"Evacuate",
"read",
"the",
"data",
"at",
"off",
"then",
"write",
"it",
"to",
"the",
"the",
"data",
"stream",
"Keep",
"it",
"from",
"being",
"overwritten",
"by",
"new",
"data",
"."
] |
142b9e1225b0ecdbe420d8fe6cef33f268670c42
|
https://github.com/coocood/freecache/blob/142b9e1225b0ecdbe420d8fe6cef33f268670c42/ringbuf.go#L158-L207
|
148,019 |
huandu/facebook
|
paging_result.go
|
Previous
|
func (pr *PagingResult) Previous() (noMore bool, err error) {
if !pr.HasPrevious() {
noMore = true
return
}
return pr.navigate(&pr.previous)
}
|
go
|
func (pr *PagingResult) Previous() (noMore bool, err error) {
if !pr.HasPrevious() {
noMore = true
return
}
return pr.navigate(&pr.previous)
}
|
[
"func",
"(",
"pr",
"*",
"PagingResult",
")",
"Previous",
"(",
")",
"(",
"noMore",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"!",
"pr",
".",
"HasPrevious",
"(",
")",
"{",
"noMore",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"pr",
".",
"navigate",
"(",
"&",
"pr",
".",
"previous",
")",
"\n",
"}"
] |
// Previous reads previous page.
|
[
"Previous",
"reads",
"previous",
"page",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/paging_result.go#L64-L71
|
148,020 |
huandu/facebook
|
paging_result.go
|
Next
|
func (pr *PagingResult) Next() (noMore bool, err error) {
if !pr.HasNext() {
noMore = true
return
}
return pr.navigate(&pr.next)
}
|
go
|
func (pr *PagingResult) Next() (noMore bool, err error) {
if !pr.HasNext() {
noMore = true
return
}
return pr.navigate(&pr.next)
}
|
[
"func",
"(",
"pr",
"*",
"PagingResult",
")",
"Next",
"(",
")",
"(",
"noMore",
"bool",
",",
"err",
"error",
")",
"{",
"if",
"!",
"pr",
".",
"HasNext",
"(",
")",
"{",
"noMore",
"=",
"true",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"pr",
".",
"navigate",
"(",
"&",
"pr",
".",
"next",
")",
"\n",
"}"
] |
// Next reads next page.
|
[
"Next",
"reads",
"next",
"page",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/paging_result.go#L74-L81
|
148,021 |
huandu/facebook
|
filedata.go
|
Data
|
func Data(filename string, source io.Reader) *BinaryData {
return &BinaryData{
Filename: filename,
Source: source,
}
}
|
go
|
func Data(filename string, source io.Reader) *BinaryData {
return &BinaryData{
Filename: filename,
Source: source,
}
}
|
[
"func",
"Data",
"(",
"filename",
"string",
",",
"source",
"io",
".",
"Reader",
")",
"*",
"BinaryData",
"{",
"return",
"&",
"BinaryData",
"{",
"Filename",
":",
"filename",
",",
"Source",
":",
"source",
",",
"}",
"\n",
"}"
] |
// Data creates new binary data holder.
|
[
"Data",
"creates",
"new",
"binary",
"data",
"holder",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/filedata.go#L29-L34
|
148,022 |
huandu/facebook
|
filedata.go
|
DataWithContentType
|
func DataWithContentType(filename string, source io.Reader, contentType string) *BinaryData {
return &BinaryData{
Filename: filename,
Source: source,
ContentType: contentType,
}
}
|
go
|
func DataWithContentType(filename string, source io.Reader, contentType string) *BinaryData {
return &BinaryData{
Filename: filename,
Source: source,
ContentType: contentType,
}
}
|
[
"func",
"DataWithContentType",
"(",
"filename",
"string",
",",
"source",
"io",
".",
"Reader",
",",
"contentType",
"string",
")",
"*",
"BinaryData",
"{",
"return",
"&",
"BinaryData",
"{",
"Filename",
":",
"filename",
",",
"Source",
":",
"source",
",",
"ContentType",
":",
"contentType",
",",
"}",
"\n",
"}"
] |
// DataWithContentType creates new binary data holder with arbitrary content type.
|
[
"DataWithContentType",
"creates",
"new",
"binary",
"data",
"holder",
"with",
"arbitrary",
"content",
"type",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/filedata.go#L37-L43
|
148,023 |
huandu/facebook
|
filedata.go
|
FileAlias
|
func FileAlias(filename, path string) *BinaryFile {
return &BinaryFile{
Filename: filename,
Path: path,
}
}
|
go
|
func FileAlias(filename, path string) *BinaryFile {
return &BinaryFile{
Filename: filename,
Path: path,
}
}
|
[
"func",
"FileAlias",
"(",
"filename",
",",
"path",
"string",
")",
"*",
"BinaryFile",
"{",
"return",
"&",
"BinaryFile",
"{",
"Filename",
":",
"filename",
",",
"Path",
":",
"path",
",",
"}",
"\n",
"}"
] |
// FileAlias creates a binary file holder and specific a different path for reading.
|
[
"FileAlias",
"creates",
"a",
"binary",
"file",
"holder",
"and",
"specific",
"a",
"different",
"path",
"for",
"reading",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/filedata.go#L53-L58
|
148,024 |
huandu/facebook
|
filedata.go
|
FileAliasWithContentType
|
func FileAliasWithContentType(filename, path, contentType string) *BinaryFile {
if path == "" {
path = filename
}
return &BinaryFile{
Filename: filename,
Path: path,
ContentType: contentType,
}
}
|
go
|
func FileAliasWithContentType(filename, path, contentType string) *BinaryFile {
if path == "" {
path = filename
}
return &BinaryFile{
Filename: filename,
Path: path,
ContentType: contentType,
}
}
|
[
"func",
"FileAliasWithContentType",
"(",
"filename",
",",
"path",
",",
"contentType",
"string",
")",
"*",
"BinaryFile",
"{",
"if",
"path",
"==",
"\"",
"\"",
"{",
"path",
"=",
"filename",
"\n",
"}",
"\n\n",
"return",
"&",
"BinaryFile",
"{",
"Filename",
":",
"filename",
",",
"Path",
":",
"path",
",",
"ContentType",
":",
"contentType",
",",
"}",
"\n",
"}"
] |
// FileAliasWithContentType creates a new binary file holder with arbitrary content type.
|
[
"FileAliasWithContentType",
"creates",
"a",
"new",
"binary",
"file",
"holder",
"with",
"arbitrary",
"content",
"type",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/filedata.go#L61-L71
|
148,025 |
huandu/facebook
|
app.go
|
New
|
func New(appID, appSecret string) *App {
return &App{
AppId: appID,
AppSecret: appSecret,
}
}
|
go
|
func New(appID, appSecret string) *App {
return &App{
AppId: appID,
AppSecret: appSecret,
}
}
|
[
"func",
"New",
"(",
"appID",
",",
"appSecret",
"string",
")",
"*",
"App",
"{",
"return",
"&",
"App",
"{",
"AppId",
":",
"appID",
",",
"AppSecret",
":",
"appSecret",
",",
"}",
"\n",
"}"
] |
// New creates a new App and sets app id and secret.
|
[
"New",
"creates",
"a",
"new",
"App",
"and",
"sets",
"app",
"id",
"and",
"secret",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L36-L41
|
148,026 |
huandu/facebook
|
app.go
|
ParseSignedRequest
|
func (app *App) ParseSignedRequest(signedRequest string) (res Result, err error) {
strs := strings.SplitN(signedRequest, ".", 2)
if len(strs) != 2 {
err = fmt.Errorf("invalid signed request format")
return
}
sig, e1 := base64.RawURLEncoding.DecodeString(strs[0])
if e1 != nil {
err = fmt.Errorf("fail to decode signed request sig with error %v", e1)
return
}
payload, e2 := base64.RawURLEncoding.DecodeString(strs[1])
if e2 != nil {
err = fmt.Errorf("fail to decode signed request payload with error is %v", e2)
return
}
err = json.Unmarshal(payload, &res)
if err != nil {
err = fmt.Errorf("signed request payload is not a valid json string with error %v", err)
return
}
var hashMethod string
err = res.DecodeField("algorithm", &hashMethod)
if err != nil {
err = fmt.Errorf("signed request payload doesn't contains a valid 'algorithm' field")
return
}
hashMethod = strings.ToUpper(hashMethod)
if hashMethod != "HMAC-SHA256" {
err = fmt.Errorf("signed request payload uses an unknown HMAC method; expect 'HMAC-SHA256' but actual is '%v'", hashMethod)
return
}
hash := hmac.New(sha256.New, []byte(app.AppSecret))
hash.Write([]byte(strs[1])) // note: here uses the payload base64 string, not decoded bytes
expectedSig := hash.Sum(nil)
if !hmac.Equal(sig, expectedSig) {
err = fmt.Errorf("bad signed request signiture")
return
}
return
}
|
go
|
func (app *App) ParseSignedRequest(signedRequest string) (res Result, err error) {
strs := strings.SplitN(signedRequest, ".", 2)
if len(strs) != 2 {
err = fmt.Errorf("invalid signed request format")
return
}
sig, e1 := base64.RawURLEncoding.DecodeString(strs[0])
if e1 != nil {
err = fmt.Errorf("fail to decode signed request sig with error %v", e1)
return
}
payload, e2 := base64.RawURLEncoding.DecodeString(strs[1])
if e2 != nil {
err = fmt.Errorf("fail to decode signed request payload with error is %v", e2)
return
}
err = json.Unmarshal(payload, &res)
if err != nil {
err = fmt.Errorf("signed request payload is not a valid json string with error %v", err)
return
}
var hashMethod string
err = res.DecodeField("algorithm", &hashMethod)
if err != nil {
err = fmt.Errorf("signed request payload doesn't contains a valid 'algorithm' field")
return
}
hashMethod = strings.ToUpper(hashMethod)
if hashMethod != "HMAC-SHA256" {
err = fmt.Errorf("signed request payload uses an unknown HMAC method; expect 'HMAC-SHA256' but actual is '%v'", hashMethod)
return
}
hash := hmac.New(sha256.New, []byte(app.AppSecret))
hash.Write([]byte(strs[1])) // note: here uses the payload base64 string, not decoded bytes
expectedSig := hash.Sum(nil)
if !hmac.Equal(sig, expectedSig) {
err = fmt.Errorf("bad signed request signiture")
return
}
return
}
|
[
"func",
"(",
"app",
"*",
"App",
")",
"ParseSignedRequest",
"(",
"signedRequest",
"string",
")",
"(",
"res",
"Result",
",",
"err",
"error",
")",
"{",
"strs",
":=",
"strings",
".",
"SplitN",
"(",
"signedRequest",
",",
"\"",
"\"",
",",
"2",
")",
"\n\n",
"if",
"len",
"(",
"strs",
")",
"!=",
"2",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"sig",
",",
"e1",
":=",
"base64",
".",
"RawURLEncoding",
".",
"DecodeString",
"(",
"strs",
"[",
"0",
"]",
")",
"\n\n",
"if",
"e1",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e1",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"payload",
",",
"e2",
":=",
"base64",
".",
"RawURLEncoding",
".",
"DecodeString",
"(",
"strs",
"[",
"1",
"]",
")",
"\n\n",
"if",
"e2",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"e2",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"payload",
",",
"&",
"res",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"hashMethod",
"string",
"\n",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"hashMethod",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"hashMethod",
"=",
"strings",
".",
"ToUpper",
"(",
"hashMethod",
")",
"\n\n",
"if",
"hashMethod",
"!=",
"\"",
"\"",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"hashMethod",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"hash",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"[",
"]",
"byte",
"(",
"app",
".",
"AppSecret",
")",
")",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"strs",
"[",
"1",
"]",
")",
")",
"// note: here uses the payload base64 string, not decoded bytes",
"\n",
"expectedSig",
":=",
"hash",
".",
"Sum",
"(",
"nil",
")",
"\n\n",
"if",
"!",
"hmac",
".",
"Equal",
"(",
"sig",
",",
"expectedSig",
")",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// ParseSignedRequest parses signed request.
|
[
"ParseSignedRequest",
"parses",
"signed",
"request",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L49-L103
|
148,027 |
huandu/facebook
|
app.go
|
ExchangeToken
|
func (app *App) ExchangeToken(accessToken string) (token string, expires int, err error) {
if accessToken == "" {
err = fmt.Errorf("short lived accessToken is empty")
return
}
var res Result
res, err = defaultSession.sendOauthRequest("/oauth/access_token", Params{
"grant_type": "fb_exchange_token",
"client_id": app.AppId,
"client_secret": app.AppSecret,
"fb_exchange_token": accessToken,
})
if err != nil {
err = fmt.Errorf("fail to parse facebook response with error %v", err)
return
}
err = res.DecodeField("access_token", &token)
if err != nil {
return
}
expiresKey := "expires_in"
if _, ok := res["expires"]; ok {
expiresKey = "expires"
}
if _, ok := res[expiresKey]; ok {
err = res.DecodeField(expiresKey, &expires)
}
return
}
|
go
|
func (app *App) ExchangeToken(accessToken string) (token string, expires int, err error) {
if accessToken == "" {
err = fmt.Errorf("short lived accessToken is empty")
return
}
var res Result
res, err = defaultSession.sendOauthRequest("/oauth/access_token", Params{
"grant_type": "fb_exchange_token",
"client_id": app.AppId,
"client_secret": app.AppSecret,
"fb_exchange_token": accessToken,
})
if err != nil {
err = fmt.Errorf("fail to parse facebook response with error %v", err)
return
}
err = res.DecodeField("access_token", &token)
if err != nil {
return
}
expiresKey := "expires_in"
if _, ok := res["expires"]; ok {
expiresKey = "expires"
}
if _, ok := res[expiresKey]; ok {
err = res.DecodeField(expiresKey, &expires)
}
return
}
|
[
"func",
"(",
"app",
"*",
"App",
")",
"ExchangeToken",
"(",
"accessToken",
"string",
")",
"(",
"token",
"string",
",",
"expires",
"int",
",",
"err",
"error",
")",
"{",
"if",
"accessToken",
"==",
"\"",
"\"",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"res",
"Result",
"\n",
"res",
",",
"err",
"=",
"defaultSession",
".",
"sendOauthRequest",
"(",
"\"",
"\"",
",",
"Params",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"app",
".",
"AppId",
",",
"\"",
"\"",
":",
"app",
".",
"AppSecret",
",",
"\"",
"\"",
":",
"accessToken",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"token",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"expiresKey",
":=",
"\"",
"\"",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"res",
"[",
"\"",
"\"",
"]",
";",
"ok",
"{",
"expiresKey",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"res",
"[",
"expiresKey",
"]",
";",
"ok",
"{",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"expiresKey",
",",
"&",
"expires",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// ExchangeToken exchanges a short-lived access token to a long-lived access token.
// Return new access token and its expires time.
|
[
"ExchangeToken",
"exchanges",
"a",
"short",
"-",
"lived",
"access",
"token",
"to",
"a",
"long",
"-",
"lived",
"access",
"token",
".",
"Return",
"new",
"access",
"token",
"and",
"its",
"expires",
"time",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L168-L204
|
148,028 |
huandu/facebook
|
app.go
|
GetCode
|
func (app *App) GetCode(accessToken string) (code string, err error) {
if accessToken == "" {
err = fmt.Errorf("long lived accessToken is empty")
return
}
var res Result
res, err = defaultSession.sendOauthRequest("/oauth/client_code", Params{
"client_id": app.AppId,
"client_secret": app.AppSecret,
"redirect_uri": app.RedirectUri,
"access_token": accessToken,
})
if err != nil {
err = fmt.Errorf("fail to get code from facebook with error %v", err)
return
}
err = res.DecodeField("code", &code)
return
}
|
go
|
func (app *App) GetCode(accessToken string) (code string, err error) {
if accessToken == "" {
err = fmt.Errorf("long lived accessToken is empty")
return
}
var res Result
res, err = defaultSession.sendOauthRequest("/oauth/client_code", Params{
"client_id": app.AppId,
"client_secret": app.AppSecret,
"redirect_uri": app.RedirectUri,
"access_token": accessToken,
})
if err != nil {
err = fmt.Errorf("fail to get code from facebook with error %v", err)
return
}
err = res.DecodeField("code", &code)
return
}
|
[
"func",
"(",
"app",
"*",
"App",
")",
"GetCode",
"(",
"accessToken",
"string",
")",
"(",
"code",
"string",
",",
"err",
"error",
")",
"{",
"if",
"accessToken",
"==",
"\"",
"\"",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"res",
"Result",
"\n",
"res",
",",
"err",
"=",
"defaultSession",
".",
"sendOauthRequest",
"(",
"\"",
"\"",
",",
"Params",
"{",
"\"",
"\"",
":",
"app",
".",
"AppId",
",",
"\"",
"\"",
":",
"app",
".",
"AppSecret",
",",
"\"",
"\"",
":",
"app",
".",
"RedirectUri",
",",
"\"",
"\"",
":",
"accessToken",
",",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"code",
")",
"\n",
"return",
"\n",
"}"
] |
// GetCode gets code from a long lived access token.
// Return the code retrieved from facebook.
|
[
"GetCode",
"gets",
"code",
"from",
"a",
"long",
"lived",
"access",
"token",
".",
"Return",
"the",
"code",
"retrieved",
"from",
"facebook",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L208-L229
|
148,029 |
huandu/facebook
|
app.go
|
Session
|
func (app *App) Session(accessToken string) *Session {
return &Session{
accessToken: accessToken,
app: app,
enableAppsecretProof: app.EnableAppsecretProof,
}
}
|
go
|
func (app *App) Session(accessToken string) *Session {
return &Session{
accessToken: accessToken,
app: app,
enableAppsecretProof: app.EnableAppsecretProof,
}
}
|
[
"func",
"(",
"app",
"*",
"App",
")",
"Session",
"(",
"accessToken",
"string",
")",
"*",
"Session",
"{",
"return",
"&",
"Session",
"{",
"accessToken",
":",
"accessToken",
",",
"app",
":",
"app",
",",
"enableAppsecretProof",
":",
"app",
".",
"EnableAppsecretProof",
",",
"}",
"\n",
"}"
] |
// Session creates a session based on current App setting.
|
[
"Session",
"creates",
"a",
"session",
"based",
"on",
"current",
"App",
"setting",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L232-L238
|
148,030 |
huandu/facebook
|
app.go
|
SessionFromSignedRequest
|
func (app *App) SessionFromSignedRequest(signedRequest string) (session *Session, err error) {
var res Result
res, err = app.ParseSignedRequest(signedRequest)
if err != nil {
return
}
var id, token string
res.DecodeField("user_id", &id) // it's ok without user id.
err = res.DecodeField("oauth_token", &token)
if err == nil {
session = &Session{
accessToken: token,
app: app,
id: id,
enableAppsecretProof: app.EnableAppsecretProof,
}
return
}
// cannot get "oauth_token"? try to get "code".
err = res.DecodeField("code", &token)
if err != nil {
// no code? no way to continue.
err = fmt.Errorf("cannot find 'oauth_token' and 'code'; unable to continue")
return
}
token, err = app.ParseCode(token)
if err != nil {
return
}
session = &Session{
accessToken: token,
app: app,
id: id,
enableAppsecretProof: app.EnableAppsecretProof,
}
return
}
|
go
|
func (app *App) SessionFromSignedRequest(signedRequest string) (session *Session, err error) {
var res Result
res, err = app.ParseSignedRequest(signedRequest)
if err != nil {
return
}
var id, token string
res.DecodeField("user_id", &id) // it's ok without user id.
err = res.DecodeField("oauth_token", &token)
if err == nil {
session = &Session{
accessToken: token,
app: app,
id: id,
enableAppsecretProof: app.EnableAppsecretProof,
}
return
}
// cannot get "oauth_token"? try to get "code".
err = res.DecodeField("code", &token)
if err != nil {
// no code? no way to continue.
err = fmt.Errorf("cannot find 'oauth_token' and 'code'; unable to continue")
return
}
token, err = app.ParseCode(token)
if err != nil {
return
}
session = &Session{
accessToken: token,
app: app,
id: id,
enableAppsecretProof: app.EnableAppsecretProof,
}
return
}
|
[
"func",
"(",
"app",
"*",
"App",
")",
"SessionFromSignedRequest",
"(",
"signedRequest",
"string",
")",
"(",
"session",
"*",
"Session",
",",
"err",
"error",
")",
"{",
"var",
"res",
"Result",
"\n\n",
"res",
",",
"err",
"=",
"app",
".",
"ParseSignedRequest",
"(",
"signedRequest",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"var",
"id",
",",
"token",
"string",
"\n\n",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"id",
")",
"// it's ok without user id.",
"\n",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"token",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"session",
"=",
"&",
"Session",
"{",
"accessToken",
":",
"token",
",",
"app",
":",
"app",
",",
"id",
":",
"id",
",",
"enableAppsecretProof",
":",
"app",
".",
"EnableAppsecretProof",
",",
"}",
"\n",
"return",
"\n",
"}",
"\n\n",
"// cannot get \"oauth_token\"? try to get \"code\".",
"err",
"=",
"res",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"token",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"// no code? no way to continue.",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"token",
",",
"err",
"=",
"app",
".",
"ParseCode",
"(",
"token",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"session",
"=",
"&",
"Session",
"{",
"accessToken",
":",
"token",
",",
"app",
":",
"app",
",",
"id",
":",
"id",
",",
"enableAppsecretProof",
":",
"app",
".",
"EnableAppsecretProof",
",",
"}",
"\n",
"return",
"\n",
"}"
] |
// SessionFromSignedRequest creates a session from a signed request.
// If signed request contains a code, it will automatically use this code
// to exchange a valid access token.
|
[
"SessionFromSignedRequest",
"creates",
"a",
"session",
"from",
"a",
"signed",
"request",
".",
"If",
"signed",
"request",
"contains",
"a",
"code",
"it",
"will",
"automatically",
"use",
"this",
"code",
"to",
"exchange",
"a",
"valid",
"access",
"token",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/app.go#L243-L289
|
148,031 |
huandu/facebook
|
session.go
|
Api
|
func (session *Session) Api(path string, method Method, params Params) (Result, error) {
return session.graph(path, method, params)
}
|
go
|
func (session *Session) Api(path string, method Method, params Params) (Result, error) {
return session.graph(path, method, params)
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"Api",
"(",
"path",
"string",
",",
"method",
"Method",
",",
"params",
"Params",
")",
"(",
"Result",
",",
"error",
")",
"{",
"return",
"session",
".",
"graph",
"(",
"path",
",",
"method",
",",
"params",
")",
"\n",
"}"
] |
// Api makes a facebook graph api call.
//
// If session access token is set, "access_token" in params will be set to the token value.
//
// Returns facebook graph api call result.
// If facebook returns error in response, returns error details in res and set err.
|
[
"Api",
"makes",
"a",
"facebook",
"graph",
"api",
"call",
".",
"If",
"session",
"access",
"token",
"is",
"set",
"access_token",
"in",
"params",
"will",
"be",
"set",
"to",
"the",
"token",
"value",
".",
"Returns",
"facebook",
"graph",
"api",
"call",
"result",
".",
"If",
"facebook",
"returns",
"error",
"in",
"response",
"returns",
"error",
"details",
"in",
"res",
"and",
"set",
"err",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L84-L86
|
148,032 |
huandu/facebook
|
session.go
|
User
|
func (session *Session) User() (id string, err error) {
if session.id != "" {
id = session.id
return
}
if session.accessToken == "" && session.HttpClient == nil {
err = fmt.Errorf("access token is not set")
return
}
var result Result
result, err = session.Api("/me", GET, Params{"fields": "id"})
if err != nil {
return
}
err = result.DecodeField("id", &id)
if err != nil {
return
}
return
}
|
go
|
func (session *Session) User() (id string, err error) {
if session.id != "" {
id = session.id
return
}
if session.accessToken == "" && session.HttpClient == nil {
err = fmt.Errorf("access token is not set")
return
}
var result Result
result, err = session.Api("/me", GET, Params{"fields": "id"})
if err != nil {
return
}
err = result.DecodeField("id", &id)
if err != nil {
return
}
return
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"User",
"(",
")",
"(",
"id",
"string",
",",
"err",
"error",
")",
"{",
"if",
"session",
".",
"id",
"!=",
"\"",
"\"",
"{",
"id",
"=",
"session",
".",
"id",
"\n",
"return",
"\n",
"}",
"\n\n",
"if",
"session",
".",
"accessToken",
"==",
"\"",
"\"",
"&&",
"session",
".",
"HttpClient",
"==",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"result",
"Result",
"\n",
"result",
",",
"err",
"=",
"session",
".",
"Api",
"(",
"\"",
"\"",
",",
"GET",
",",
"Params",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"err",
"=",
"result",
".",
"DecodeField",
"(",
"\"",
"\"",
",",
"&",
"id",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// User gets current user id from access token.
//
// Returns error if access token is not set or invalid.
//
// It's a standard way to validate a facebook access token.
|
[
"User",
"gets",
"current",
"user",
"id",
"from",
"access",
"token",
".",
"Returns",
"error",
"if",
"access",
"token",
"is",
"not",
"set",
"or",
"invalid",
".",
"It",
"s",
"a",
"standard",
"way",
"to",
"validate",
"a",
"facebook",
"access",
"token",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L163-L188
|
148,033 |
huandu/facebook
|
session.go
|
Validate
|
func (session *Session) Validate() (err error) {
if session.accessToken == "" && session.HttpClient == nil {
err = fmt.Errorf("access token is not set")
return
}
var result Result
result, err = session.Api("/me", GET, Params{"fields": "id"})
if err != nil {
return
}
if f := result.Get("id"); f == nil {
err = fmt.Errorf("invalid access token")
return
}
return
}
|
go
|
func (session *Session) Validate() (err error) {
if session.accessToken == "" && session.HttpClient == nil {
err = fmt.Errorf("access token is not set")
return
}
var result Result
result, err = session.Api("/me", GET, Params{"fields": "id"})
if err != nil {
return
}
if f := result.Get("id"); f == nil {
err = fmt.Errorf("invalid access token")
return
}
return
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"Validate",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"session",
".",
"accessToken",
"==",
"\"",
"\"",
"&&",
"session",
".",
"HttpClient",
"==",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"var",
"result",
"Result",
"\n",
"result",
",",
"err",
"=",
"session",
".",
"Api",
"(",
"\"",
"\"",
",",
"GET",
",",
"Params",
"{",
"\"",
"\"",
":",
"\"",
"\"",
"}",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"f",
":=",
"result",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"f",
"==",
"nil",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] |
// Validate validates Session access token.
// Returns nil if access token is valid.
|
[
"Validate",
"validates",
"Session",
"access",
"token",
".",
"Returns",
"nil",
"if",
"access",
"token",
"is",
"valid",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L192-L211
|
148,034 |
huandu/facebook
|
session.go
|
SetAccessToken
|
func (session *Session) SetAccessToken(token string) {
if token != session.accessToken {
session.id = ""
session.accessToken = token
session.appsecretProof = ""
}
}
|
go
|
func (session *Session) SetAccessToken(token string) {
if token != session.accessToken {
session.id = ""
session.accessToken = token
session.appsecretProof = ""
}
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"SetAccessToken",
"(",
"token",
"string",
")",
"{",
"if",
"token",
"!=",
"session",
".",
"accessToken",
"{",
"session",
".",
"id",
"=",
"\"",
"\"",
"\n",
"session",
".",
"accessToken",
"=",
"token",
"\n",
"session",
".",
"appsecretProof",
"=",
"\"",
"\"",
"\n",
"}",
"\n",
"}"
] |
// SetAccessToken sets a new access token.
|
[
"SetAccessToken",
"sets",
"a",
"new",
"access",
"token",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L263-L269
|
148,035 |
huandu/facebook
|
session.go
|
AppsecretProof
|
func (session *Session) AppsecretProof() string {
if !session.enableAppsecretProof {
return ""
}
if session.accessToken == "" || session.app == nil {
return ""
}
if session.appsecretProof == "" {
hash := hmac.New(sha256.New, []byte(session.app.AppSecret))
hash.Write([]byte(session.accessToken))
session.appsecretProof = hex.EncodeToString(hash.Sum(nil))
}
return session.appsecretProof
}
|
go
|
func (session *Session) AppsecretProof() string {
if !session.enableAppsecretProof {
return ""
}
if session.accessToken == "" || session.app == nil {
return ""
}
if session.appsecretProof == "" {
hash := hmac.New(sha256.New, []byte(session.app.AppSecret))
hash.Write([]byte(session.accessToken))
session.appsecretProof = hex.EncodeToString(hash.Sum(nil))
}
return session.appsecretProof
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"AppsecretProof",
"(",
")",
"string",
"{",
"if",
"!",
"session",
".",
"enableAppsecretProof",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"session",
".",
"accessToken",
"==",
"\"",
"\"",
"||",
"session",
".",
"app",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"if",
"session",
".",
"appsecretProof",
"==",
"\"",
"\"",
"{",
"hash",
":=",
"hmac",
".",
"New",
"(",
"sha256",
".",
"New",
",",
"[",
"]",
"byte",
"(",
"session",
".",
"app",
".",
"AppSecret",
")",
")",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"session",
".",
"accessToken",
")",
")",
"\n",
"session",
".",
"appsecretProof",
"=",
"hex",
".",
"EncodeToString",
"(",
"hash",
".",
"Sum",
"(",
"nil",
")",
")",
"\n",
"}",
"\n\n",
"return",
"session",
".",
"appsecretProof",
"\n",
"}"
] |
// AppsecretProof checks appsecret proof is enabled or not.
|
[
"AppsecretProof",
"checks",
"appsecret",
"proof",
"is",
"enabled",
"or",
"not",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L272-L288
|
148,036 |
huandu/facebook
|
session.go
|
EnableAppsecretProof
|
func (session *Session) EnableAppsecretProof(enabled bool) error {
if session.app == nil {
return fmt.Errorf("cannot change appsecret proof status without an associated App")
}
if session.enableAppsecretProof != enabled {
session.enableAppsecretProof = enabled
// reset pre-calculated proof here to give caller a way to do so in some rare case,
// e.g. associated app's secret is changed.
session.appsecretProof = ""
}
return nil
}
|
go
|
func (session *Session) EnableAppsecretProof(enabled bool) error {
if session.app == nil {
return fmt.Errorf("cannot change appsecret proof status without an associated App")
}
if session.enableAppsecretProof != enabled {
session.enableAppsecretProof = enabled
// reset pre-calculated proof here to give caller a way to do so in some rare case,
// e.g. associated app's secret is changed.
session.appsecretProof = ""
}
return nil
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"EnableAppsecretProof",
"(",
"enabled",
"bool",
")",
"error",
"{",
"if",
"session",
".",
"app",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"session",
".",
"enableAppsecretProof",
"!=",
"enabled",
"{",
"session",
".",
"enableAppsecretProof",
"=",
"enabled",
"\n\n",
"// reset pre-calculated proof here to give caller a way to do so in some rare case,",
"// e.g. associated app's secret is changed.",
"session",
".",
"appsecretProof",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// EnableAppsecretProof enables or disable appsecret proof status.
// Returns error if there is no App associated with this Session.
|
[
"EnableAppsecretProof",
"enables",
"or",
"disable",
"appsecret",
"proof",
"status",
".",
"Returns",
"error",
"if",
"there",
"is",
"no",
"App",
"associated",
"with",
"this",
"Session",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L292-L306
|
148,037 |
huandu/facebook
|
session.go
|
Debug
|
func (session *Session) Debug() DebugMode {
if session.debug != DEBUG_OFF {
return session.debug
}
return Debug
}
|
go
|
func (session *Session) Debug() DebugMode {
if session.debug != DEBUG_OFF {
return session.debug
}
return Debug
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"Debug",
"(",
")",
"DebugMode",
"{",
"if",
"session",
".",
"debug",
"!=",
"DEBUG_OFF",
"{",
"return",
"session",
".",
"debug",
"\n",
"}",
"\n\n",
"return",
"Debug",
"\n",
"}"
] |
// Debug returns current debug mode.
|
[
"Debug",
"returns",
"current",
"debug",
"mode",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L314-L320
|
148,038 |
huandu/facebook
|
session.go
|
SetDebug
|
func (session *Session) SetDebug(debug DebugMode) DebugMode {
old := session.debug
session.debug = debug
return old
}
|
go
|
func (session *Session) SetDebug(debug DebugMode) DebugMode {
old := session.debug
session.debug = debug
return old
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"SetDebug",
"(",
"debug",
"DebugMode",
")",
"DebugMode",
"{",
"old",
":=",
"session",
".",
"debug",
"\n",
"session",
".",
"debug",
"=",
"debug",
"\n",
"return",
"old",
"\n",
"}"
] |
// SetDebug updates per session debug mode and returns old mode.
// If per session debug mode is DEBUG_OFF, session will use global
// Debug mode.
|
[
"SetDebug",
"updates",
"per",
"session",
"debug",
"mode",
"and",
"returns",
"old",
"mode",
".",
"If",
"per",
"session",
"debug",
"mode",
"is",
"DEBUG_OFF",
"session",
"will",
"use",
"global",
"Debug",
"mode",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L325-L329
|
148,039 |
huandu/facebook
|
session.go
|
WithContext
|
func (session *Session) WithContext(ctx context.Context) *Session {
s := *session
s.context = ctx
return &s
}
|
go
|
func (session *Session) WithContext(ctx context.Context) *Session {
s := *session
s.context = ctx
return &s
}
|
[
"func",
"(",
"session",
"*",
"Session",
")",
"WithContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"*",
"Session",
"{",
"s",
":=",
"*",
"session",
"\n",
"s",
".",
"context",
"=",
"ctx",
"\n",
"return",
"&",
"s",
"\n",
"}"
] |
// WithContext returns a shallow copy of session with its context changed to ctx.
// The provided ctx must be non-nil.
|
[
"WithContext",
"returns",
"a",
"shallow",
"copy",
"of",
"session",
"with",
"its",
"context",
"changed",
"to",
"ctx",
".",
"The",
"provided",
"ctx",
"must",
"be",
"non",
"-",
"nil",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/session.go#L656-L660
|
148,040 |
huandu/facebook
|
result.go
|
MakeResult
|
func MakeResult(jsonBytes []byte) (Result, error) {
res := Result{}
err := makeResult(jsonBytes, &res)
if err != nil {
return nil, err
}
// facebook may return an error
return res, res.Err()
}
|
go
|
func MakeResult(jsonBytes []byte) (Result, error) {
res := Result{}
err := makeResult(jsonBytes, &res)
if err != nil {
return nil, err
}
// facebook may return an error
return res, res.Err()
}
|
[
"func",
"MakeResult",
"(",
"jsonBytes",
"[",
"]",
"byte",
")",
"(",
"Result",
",",
"error",
")",
"{",
"res",
":=",
"Result",
"{",
"}",
"\n",
"err",
":=",
"makeResult",
"(",
"jsonBytes",
",",
"&",
"res",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// facebook may return an error",
"return",
"res",
",",
"res",
".",
"Err",
"(",
")",
"\n",
"}"
] |
// MakeResult makes a Result from facebook Graph API response.
|
[
"MakeResult",
"makes",
"a",
"Result",
"from",
"facebook",
"Graph",
"API",
"response",
"."
] |
2d3753b3eead5325f72a52b940da5d36ed611aa4
|
https://github.com/huandu/facebook/blob/2d3753b3eead5325f72a52b940da5d36ed611aa4/result.go#L129-L139
|
148,041 |
alecthomas/kingpin
|
app.go
|
New
|
func New(name, help string) *Application {
a := &Application{
Name: name,
Help: help,
errorWriter: os.Stderr, // Left for backwards compatibility purposes.
usageWriter: os.Stderr,
usageTemplate: DefaultUsageTemplate,
terminate: os.Exit,
}
a.flagGroup = newFlagGroup()
a.argGroup = newArgGroup()
a.cmdGroup = newCmdGroup(a)
a.HelpFlag = a.Flag("help", "Show context-sensitive help (also try --help-long and --help-man).")
a.HelpFlag.Bool()
a.Flag("help-long", "Generate long help.").Hidden().PreAction(a.generateLongHelp).Bool()
a.Flag("help-man", "Generate a man page.").Hidden().PreAction(a.generateManPage).Bool()
a.Flag("completion-bash", "Output possible completions for the given args.").Hidden().BoolVar(&a.completion)
a.Flag("completion-script-bash", "Generate completion script for bash.").Hidden().PreAction(a.generateBashCompletionScript).Bool()
a.Flag("completion-script-zsh", "Generate completion script for ZSH.").Hidden().PreAction(a.generateZSHCompletionScript).Bool()
return a
}
|
go
|
func New(name, help string) *Application {
a := &Application{
Name: name,
Help: help,
errorWriter: os.Stderr, // Left for backwards compatibility purposes.
usageWriter: os.Stderr,
usageTemplate: DefaultUsageTemplate,
terminate: os.Exit,
}
a.flagGroup = newFlagGroup()
a.argGroup = newArgGroup()
a.cmdGroup = newCmdGroup(a)
a.HelpFlag = a.Flag("help", "Show context-sensitive help (also try --help-long and --help-man).")
a.HelpFlag.Bool()
a.Flag("help-long", "Generate long help.").Hidden().PreAction(a.generateLongHelp).Bool()
a.Flag("help-man", "Generate a man page.").Hidden().PreAction(a.generateManPage).Bool()
a.Flag("completion-bash", "Output possible completions for the given args.").Hidden().BoolVar(&a.completion)
a.Flag("completion-script-bash", "Generate completion script for bash.").Hidden().PreAction(a.generateBashCompletionScript).Bool()
a.Flag("completion-script-zsh", "Generate completion script for ZSH.").Hidden().PreAction(a.generateZSHCompletionScript).Bool()
return a
}
|
[
"func",
"New",
"(",
"name",
",",
"help",
"string",
")",
"*",
"Application",
"{",
"a",
":=",
"&",
"Application",
"{",
"Name",
":",
"name",
",",
"Help",
":",
"help",
",",
"errorWriter",
":",
"os",
".",
"Stderr",
",",
"// Left for backwards compatibility purposes.",
"usageWriter",
":",
"os",
".",
"Stderr",
",",
"usageTemplate",
":",
"DefaultUsageTemplate",
",",
"terminate",
":",
"os",
".",
"Exit",
",",
"}",
"\n",
"a",
".",
"flagGroup",
"=",
"newFlagGroup",
"(",
")",
"\n",
"a",
".",
"argGroup",
"=",
"newArgGroup",
"(",
")",
"\n",
"a",
".",
"cmdGroup",
"=",
"newCmdGroup",
"(",
"a",
")",
"\n",
"a",
".",
"HelpFlag",
"=",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"a",
".",
"HelpFlag",
".",
"Bool",
"(",
")",
"\n",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"PreAction",
"(",
"a",
".",
"generateLongHelp",
")",
".",
"Bool",
"(",
")",
"\n",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"PreAction",
"(",
"a",
".",
"generateManPage",
")",
".",
"Bool",
"(",
")",
"\n",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"BoolVar",
"(",
"&",
"a",
".",
"completion",
")",
"\n",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"PreAction",
"(",
"a",
".",
"generateBashCompletionScript",
")",
".",
"Bool",
"(",
")",
"\n",
"a",
".",
"Flag",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
".",
"Hidden",
"(",
")",
".",
"PreAction",
"(",
"a",
".",
"generateZSHCompletionScript",
")",
".",
"Bool",
"(",
")",
"\n\n",
"return",
"a",
"\n",
"}"
] |
// New creates a new Kingpin application instance.
|
[
"New",
"creates",
"a",
"new",
"Kingpin",
"application",
"instance",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L50-L71
|
148,042 |
alecthomas/kingpin
|
app.go
|
ErrorWriter
|
func (a *Application) ErrorWriter(w io.Writer) *Application {
a.errorWriter = w
return a
}
|
go
|
func (a *Application) ErrorWriter(w io.Writer) *Application {
a.errorWriter = w
return a
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"ErrorWriter",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"Application",
"{",
"a",
".",
"errorWriter",
"=",
"w",
"\n",
"return",
"a",
"\n",
"}"
] |
// ErrorWriter sets the io.Writer to use for errors.
|
[
"ErrorWriter",
"sets",
"the",
"io",
".",
"Writer",
"to",
"use",
"for",
"errors",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L138-L141
|
148,043 |
alecthomas/kingpin
|
app.go
|
UsageWriter
|
func (a *Application) UsageWriter(w io.Writer) *Application {
a.usageWriter = w
return a
}
|
go
|
func (a *Application) UsageWriter(w io.Writer) *Application {
a.usageWriter = w
return a
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"UsageWriter",
"(",
"w",
"io",
".",
"Writer",
")",
"*",
"Application",
"{",
"a",
".",
"usageWriter",
"=",
"w",
"\n",
"return",
"a",
"\n",
"}"
] |
// UsageWriter sets the io.Writer to use for errors.
|
[
"UsageWriter",
"sets",
"the",
"io",
".",
"Writer",
"to",
"use",
"for",
"errors",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L144-L147
|
148,044 |
alecthomas/kingpin
|
app.go
|
UsageTemplate
|
func (a *Application) UsageTemplate(template string) *Application {
a.usageTemplate = template
return a
}
|
go
|
func (a *Application) UsageTemplate(template string) *Application {
a.usageTemplate = template
return a
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"UsageTemplate",
"(",
"template",
"string",
")",
"*",
"Application",
"{",
"a",
".",
"usageTemplate",
"=",
"template",
"\n",
"return",
"a",
"\n",
"}"
] |
// UsageTemplate specifies the text template to use when displaying usage
// information. The default is UsageTemplate.
|
[
"UsageTemplate",
"specifies",
"the",
"text",
"template",
"to",
"use",
"when",
"displaying",
"usage",
"information",
".",
"The",
"default",
"is",
"UsageTemplate",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L151-L154
|
148,045 |
alecthomas/kingpin
|
app.go
|
ParseContext
|
func (a *Application) ParseContext(args []string) (*ParseContext, error) {
return a.parseContext(false, args)
}
|
go
|
func (a *Application) ParseContext(args []string) (*ParseContext, error) {
return a.parseContext(false, args)
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"ParseContext",
"(",
"args",
"[",
"]",
"string",
")",
"(",
"*",
"ParseContext",
",",
"error",
")",
"{",
"return",
"a",
".",
"parseContext",
"(",
"false",
",",
"args",
")",
"\n",
"}"
] |
// ParseContext parses the given command line and returns the fully populated
// ParseContext.
|
[
"ParseContext",
"parses",
"the",
"given",
"command",
"line",
"and",
"returns",
"the",
"fully",
"populated",
"ParseContext",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L164-L166
|
148,046 |
alecthomas/kingpin
|
app.go
|
Parse
|
func (a *Application) Parse(args []string) (command string, err error) {
context, parseErr := a.ParseContext(args)
selected := []string{}
var setValuesErr error
if context == nil {
// Since we do not throw error immediately, there could be a case
// where a context returns nil. Protect against that.
return "", parseErr
}
if err = a.setDefaults(context); err != nil {
return "", err
}
selected, setValuesErr = a.setValues(context)
if err = a.applyPreActions(context, !a.completion); err != nil {
return "", err
}
if a.completion {
a.generateBashCompletion(context)
a.terminate(0)
} else {
if parseErr != nil {
return "", parseErr
}
a.maybeHelp(context)
if !context.EOL() {
return "", fmt.Errorf("unexpected argument '%s'", context.Peek())
}
if setValuesErr != nil {
return "", setValuesErr
}
command, err = a.execute(context, selected)
if err == ErrCommandNotSpecified {
a.writeUsage(context, nil)
}
}
return command, err
}
|
go
|
func (a *Application) Parse(args []string) (command string, err error) {
context, parseErr := a.ParseContext(args)
selected := []string{}
var setValuesErr error
if context == nil {
// Since we do not throw error immediately, there could be a case
// where a context returns nil. Protect against that.
return "", parseErr
}
if err = a.setDefaults(context); err != nil {
return "", err
}
selected, setValuesErr = a.setValues(context)
if err = a.applyPreActions(context, !a.completion); err != nil {
return "", err
}
if a.completion {
a.generateBashCompletion(context)
a.terminate(0)
} else {
if parseErr != nil {
return "", parseErr
}
a.maybeHelp(context)
if !context.EOL() {
return "", fmt.Errorf("unexpected argument '%s'", context.Peek())
}
if setValuesErr != nil {
return "", setValuesErr
}
command, err = a.execute(context, selected)
if err == ErrCommandNotSpecified {
a.writeUsage(context, nil)
}
}
return command, err
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"Parse",
"(",
"args",
"[",
"]",
"string",
")",
"(",
"command",
"string",
",",
"err",
"error",
")",
"{",
"context",
",",
"parseErr",
":=",
"a",
".",
"ParseContext",
"(",
"args",
")",
"\n",
"selected",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"var",
"setValuesErr",
"error",
"\n\n",
"if",
"context",
"==",
"nil",
"{",
"// Since we do not throw error immediately, there could be a case",
"// where a context returns nil. Protect against that.",
"return",
"\"",
"\"",
",",
"parseErr",
"\n",
"}",
"\n\n",
"if",
"err",
"=",
"a",
".",
"setDefaults",
"(",
"context",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"selected",
",",
"setValuesErr",
"=",
"a",
".",
"setValues",
"(",
"context",
")",
"\n\n",
"if",
"err",
"=",
"a",
".",
"applyPreActions",
"(",
"context",
",",
"!",
"a",
".",
"completion",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"a",
".",
"completion",
"{",
"a",
".",
"generateBashCompletion",
"(",
"context",
")",
"\n",
"a",
".",
"terminate",
"(",
"0",
")",
"\n",
"}",
"else",
"{",
"if",
"parseErr",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"parseErr",
"\n",
"}",
"\n\n",
"a",
".",
"maybeHelp",
"(",
"context",
")",
"\n",
"if",
"!",
"context",
".",
"EOL",
"(",
")",
"{",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"context",
".",
"Peek",
"(",
")",
")",
"\n",
"}",
"\n\n",
"if",
"setValuesErr",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"setValuesErr",
"\n",
"}",
"\n\n",
"command",
",",
"err",
"=",
"a",
".",
"execute",
"(",
"context",
",",
"selected",
")",
"\n",
"if",
"err",
"==",
"ErrCommandNotSpecified",
"{",
"a",
".",
"writeUsage",
"(",
"context",
",",
"nil",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"command",
",",
"err",
"\n",
"}"
] |
// Parse parses command-line arguments. It returns the selected command and an
// error. The selected command will be a space separated subcommand, if
// subcommands have been configured.
//
// This will populate all flag and argument values, call all callbacks, and so
// on.
|
[
"Parse",
"parses",
"command",
"-",
"line",
"arguments",
".",
"It",
"returns",
"the",
"selected",
"command",
"and",
"an",
"error",
".",
"The",
"selected",
"command",
"will",
"be",
"a",
"space",
"separated",
"subcommand",
"if",
"subcommands",
"have",
"been",
"configured",
".",
"This",
"will",
"populate",
"all",
"flag",
"and",
"argument",
"values",
"call",
"all",
"callbacks",
"and",
"so",
"on",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L183-L228
|
148,047 |
alecthomas/kingpin
|
app.go
|
Author
|
func (a *Application) Author(author string) *Application {
a.author = author
return a
}
|
go
|
func (a *Application) Author(author string) *Application {
a.author = author
return a
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"Author",
"(",
"author",
"string",
")",
"*",
"Application",
"{",
"a",
".",
"author",
"=",
"author",
"\n",
"return",
"a",
"\n",
"}"
] |
// Author sets the author output by some help templates.
|
[
"Author",
"sets",
"the",
"author",
"output",
"by",
"some",
"help",
"templates",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L267-L270
|
148,048 |
alecthomas/kingpin
|
app.go
|
PreAction
|
func (a *Application) PreAction(action Action) *Application {
a.addPreAction(action)
return a
}
|
go
|
func (a *Application) PreAction(action Action) *Application {
a.addPreAction(action)
return a
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"PreAction",
"(",
"action",
"Action",
")",
"*",
"Application",
"{",
"a",
".",
"addPreAction",
"(",
"action",
")",
"\n",
"return",
"a",
"\n",
"}"
] |
// Action called after parsing completes but before validation and execution.
|
[
"Action",
"called",
"after",
"parsing",
"completes",
"but",
"before",
"validation",
"and",
"execution",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L283-L286
|
148,049 |
alecthomas/kingpin
|
app.go
|
Command
|
func (a *Application) Command(name, help string) *CmdClause {
return a.addCommand(name, help)
}
|
go
|
func (a *Application) Command(name, help string) *CmdClause {
return a.addCommand(name, help)
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"Command",
"(",
"name",
",",
"help",
"string",
")",
"*",
"CmdClause",
"{",
"return",
"a",
".",
"addCommand",
"(",
"name",
",",
"help",
")",
"\n",
"}"
] |
// Command adds a new top-level command.
|
[
"Command",
"adds",
"a",
"new",
"top",
"-",
"level",
"command",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L289-L291
|
148,050 |
alecthomas/kingpin
|
app.go
|
checkDuplicateFlags
|
func checkDuplicateFlags(current *CmdClause, flagGroups []*flagGroup) error {
// Check for duplicates.
for _, flags := range flagGroups {
for _, flag := range current.flagOrder {
if flag.shorthand != 0 {
if _, ok := flags.short[string(flag.shorthand)]; ok {
return fmt.Errorf("duplicate short flag -%c", flag.shorthand)
}
}
if _, ok := flags.long[flag.name]; ok {
return fmt.Errorf("duplicate long flag --%s", flag.name)
}
}
}
flagGroups = append(flagGroups, current.flagGroup)
// Check subcommands.
for _, subcmd := range current.commandOrder {
if err := checkDuplicateFlags(subcmd, flagGroups); err != nil {
return err
}
}
return nil
}
|
go
|
func checkDuplicateFlags(current *CmdClause, flagGroups []*flagGroup) error {
// Check for duplicates.
for _, flags := range flagGroups {
for _, flag := range current.flagOrder {
if flag.shorthand != 0 {
if _, ok := flags.short[string(flag.shorthand)]; ok {
return fmt.Errorf("duplicate short flag -%c", flag.shorthand)
}
}
if _, ok := flags.long[flag.name]; ok {
return fmt.Errorf("duplicate long flag --%s", flag.name)
}
}
}
flagGroups = append(flagGroups, current.flagGroup)
// Check subcommands.
for _, subcmd := range current.commandOrder {
if err := checkDuplicateFlags(subcmd, flagGroups); err != nil {
return err
}
}
return nil
}
|
[
"func",
"checkDuplicateFlags",
"(",
"current",
"*",
"CmdClause",
",",
"flagGroups",
"[",
"]",
"*",
"flagGroup",
")",
"error",
"{",
"// Check for duplicates.",
"for",
"_",
",",
"flags",
":=",
"range",
"flagGroups",
"{",
"for",
"_",
",",
"flag",
":=",
"range",
"current",
".",
"flagOrder",
"{",
"if",
"flag",
".",
"shorthand",
"!=",
"0",
"{",
"if",
"_",
",",
"ok",
":=",
"flags",
".",
"short",
"[",
"string",
"(",
"flag",
".",
"shorthand",
")",
"]",
";",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"flag",
".",
"shorthand",
")",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"_",
",",
"ok",
":=",
"flags",
".",
"long",
"[",
"flag",
".",
"name",
"]",
";",
"ok",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"flag",
".",
"name",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"flagGroups",
"=",
"append",
"(",
"flagGroups",
",",
"current",
".",
"flagGroup",
")",
"\n",
"// Check subcommands.",
"for",
"_",
",",
"subcmd",
":=",
"range",
"current",
".",
"commandOrder",
"{",
"if",
"err",
":=",
"checkDuplicateFlags",
"(",
"subcmd",
",",
"flagGroups",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Recursively check commands for duplicate flags.
|
[
"Recursively",
"check",
"commands",
"for",
"duplicate",
"flags",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L355-L377
|
148,051 |
alecthomas/kingpin
|
app.go
|
Fatalf
|
func (a *Application) Fatalf(format string, args ...interface{}) {
a.Errorf(format, args...)
a.terminate(1)
}
|
go
|
func (a *Application) Fatalf(format string, args ...interface{}) {
a.Errorf(format, args...)
a.terminate(1)
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"Fatalf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"a",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"a",
".",
"terminate",
"(",
"1",
")",
"\n",
"}"
] |
// Fatalf writes a formatted error to w then terminates with exit status 1.
|
[
"Fatalf",
"writes",
"a",
"formatted",
"error",
"to",
"w",
"then",
"terminates",
"with",
"exit",
"status",
"1",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L571-L574
|
148,052 |
alecthomas/kingpin
|
app.go
|
FatalUsage
|
func (a *Application) FatalUsage(format string, args ...interface{}) {
a.Errorf(format, args...)
// Force usage to go to error output.
a.usageWriter = a.errorWriter
a.Usage([]string{})
a.terminate(1)
}
|
go
|
func (a *Application) FatalUsage(format string, args ...interface{}) {
a.Errorf(format, args...)
// Force usage to go to error output.
a.usageWriter = a.errorWriter
a.Usage([]string{})
a.terminate(1)
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"FatalUsage",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"a",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"// Force usage to go to error output.",
"a",
".",
"usageWriter",
"=",
"a",
".",
"errorWriter",
"\n",
"a",
".",
"Usage",
"(",
"[",
"]",
"string",
"{",
"}",
")",
"\n",
"a",
".",
"terminate",
"(",
"1",
")",
"\n",
"}"
] |
// FatalUsage prints an error message followed by usage information, then
// exits with a non-zero status.
|
[
"FatalUsage",
"prints",
"an",
"error",
"message",
"followed",
"by",
"usage",
"information",
"then",
"exits",
"with",
"a",
"non",
"-",
"zero",
"status",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L578-L584
|
148,053 |
alecthomas/kingpin
|
app.go
|
FatalUsageContext
|
func (a *Application) FatalUsageContext(context *ParseContext, format string, args ...interface{}) {
a.Errorf(format, args...)
if err := a.UsageForContext(context); err != nil {
panic(err)
}
a.terminate(1)
}
|
go
|
func (a *Application) FatalUsageContext(context *ParseContext, format string, args ...interface{}) {
a.Errorf(format, args...)
if err := a.UsageForContext(context); err != nil {
panic(err)
}
a.terminate(1)
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"FatalUsageContext",
"(",
"context",
"*",
"ParseContext",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"a",
".",
"Errorf",
"(",
"format",
",",
"args",
"...",
")",
"\n",
"if",
"err",
":=",
"a",
".",
"UsageForContext",
"(",
"context",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"a",
".",
"terminate",
"(",
"1",
")",
"\n",
"}"
] |
// FatalUsageContext writes a printf formatted error message to w, then usage
// information for the given ParseContext, before exiting.
|
[
"FatalUsageContext",
"writes",
"a",
"printf",
"formatted",
"error",
"message",
"to",
"w",
"then",
"usage",
"information",
"for",
"the",
"given",
"ParseContext",
"before",
"exiting",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L588-L594
|
148,054 |
alecthomas/kingpin
|
app.go
|
FatalIfError
|
func (a *Application) FatalIfError(err error, format string, args ...interface{}) {
if err != nil {
prefix := ""
if format != "" {
prefix = fmt.Sprintf(format, args...) + ": "
}
a.Errorf(prefix+"%s", err)
a.terminate(1)
}
}
|
go
|
func (a *Application) FatalIfError(err error, format string, args ...interface{}) {
if err != nil {
prefix := ""
if format != "" {
prefix = fmt.Sprintf(format, args...) + ": "
}
a.Errorf(prefix+"%s", err)
a.terminate(1)
}
}
|
[
"func",
"(",
"a",
"*",
"Application",
")",
"FatalIfError",
"(",
"err",
"error",
",",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"err",
"!=",
"nil",
"{",
"prefix",
":=",
"\"",
"\"",
"\n",
"if",
"format",
"!=",
"\"",
"\"",
"{",
"prefix",
"=",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"args",
"...",
")",
"+",
"\"",
"\"",
"\n",
"}",
"\n",
"a",
".",
"Errorf",
"(",
"prefix",
"+",
"\"",
"\"",
",",
"err",
")",
"\n",
"a",
".",
"terminate",
"(",
"1",
")",
"\n",
"}",
"\n",
"}"
] |
// FatalIfError prints an error and exits if err is not nil. The error is printed
// with the given formatted string, if any.
|
[
"FatalIfError",
"prints",
"an",
"error",
"and",
"exits",
"if",
"err",
"is",
"not",
"nil",
".",
"The",
"error",
"is",
"printed",
"with",
"the",
"given",
"formatted",
"string",
"if",
"any",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/app.go#L598-L607
|
148,055 |
alecthomas/kingpin
|
flags.go
|
Flag
|
func (f *flagGroup) Flag(name, help string) *FlagClause {
flag := newFlag(name, help)
f.long[name] = flag
f.flagOrder = append(f.flagOrder, flag)
return flag
}
|
go
|
func (f *flagGroup) Flag(name, help string) *FlagClause {
flag := newFlag(name, help)
f.long[name] = flag
f.flagOrder = append(f.flagOrder, flag)
return flag
}
|
[
"func",
"(",
"f",
"*",
"flagGroup",
")",
"Flag",
"(",
"name",
",",
"help",
"string",
")",
"*",
"FlagClause",
"{",
"flag",
":=",
"newFlag",
"(",
"name",
",",
"help",
")",
"\n",
"f",
".",
"long",
"[",
"name",
"]",
"=",
"flag",
"\n",
"f",
".",
"flagOrder",
"=",
"append",
"(",
"f",
".",
"flagOrder",
",",
"flag",
")",
"\n",
"return",
"flag",
"\n",
"}"
] |
// Flag defines a new flag with the given long name and help.
|
[
"Flag",
"defines",
"a",
"new",
"flag",
"with",
"the",
"given",
"long",
"name",
"and",
"help",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/flags.go#L30-L35
|
148,056 |
alecthomas/kingpin
|
flags.go
|
Action
|
func (f *FlagClause) Action(action Action) *FlagClause {
f.addAction(action)
return f
}
|
go
|
func (f *FlagClause) Action(action Action) *FlagClause {
f.addAction(action)
return f
}
|
[
"func",
"(",
"f",
"*",
"FlagClause",
")",
"Action",
"(",
"action",
"Action",
")",
"*",
"FlagClause",
"{",
"f",
".",
"addAction",
"(",
"action",
")",
"\n",
"return",
"f",
"\n",
"}"
] |
// Dispatch to the given function after the flag is parsed and validated.
|
[
"Dispatch",
"to",
"the",
"given",
"function",
"after",
"the",
"flag",
"is",
"parsed",
"and",
"validated",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/flags.go#L220-L223
|
148,057 |
alecthomas/kingpin
|
flags.go
|
IsSetByUser
|
func (f *FlagClause) IsSetByUser(setByUser *bool) *FlagClause {
if setByUser != nil {
*setByUser = false
}
f.setByUser = setByUser
return f
}
|
go
|
func (f *FlagClause) IsSetByUser(setByUser *bool) *FlagClause {
if setByUser != nil {
*setByUser = false
}
f.setByUser = setByUser
return f
}
|
[
"func",
"(",
"f",
"*",
"FlagClause",
")",
"IsSetByUser",
"(",
"setByUser",
"*",
"bool",
")",
"*",
"FlagClause",
"{",
"if",
"setByUser",
"!=",
"nil",
"{",
"*",
"setByUser",
"=",
"false",
"\n",
"}",
"\n",
"f",
".",
"setByUser",
"=",
"setByUser",
"\n",
"return",
"f",
"\n",
"}"
] |
// IsSetByUser let to know if the flag was set by the user
|
[
"IsSetByUser",
"let",
"to",
"know",
"if",
"the",
"flag",
"was",
"set",
"by",
"the",
"user"
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/flags.go#L259-L265
|
148,058 |
alecthomas/kingpin
|
flags.go
|
Short
|
func (f *FlagClause) Short(name rune) *FlagClause {
f.shorthand = name
return f
}
|
go
|
func (f *FlagClause) Short(name rune) *FlagClause {
f.shorthand = name
return f
}
|
[
"func",
"(",
"f",
"*",
"FlagClause",
")",
"Short",
"(",
"name",
"rune",
")",
"*",
"FlagClause",
"{",
"f",
".",
"shorthand",
"=",
"name",
"\n",
"return",
"f",
"\n",
"}"
] |
// Short sets the short flag name.
|
[
"Short",
"sets",
"the",
"short",
"flag",
"name",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/flags.go#L316-L319
|
148,059 |
alecthomas/kingpin
|
flags.go
|
Bool
|
func (f *FlagClause) Bool() (target *bool) {
target = new(bool)
f.SetValue(newBoolValue(target))
return
}
|
go
|
func (f *FlagClause) Bool() (target *bool) {
target = new(bool)
f.SetValue(newBoolValue(target))
return
}
|
[
"func",
"(",
"f",
"*",
"FlagClause",
")",
"Bool",
"(",
")",
"(",
"target",
"*",
"bool",
")",
"{",
"target",
"=",
"new",
"(",
"bool",
")",
"\n",
"f",
".",
"SetValue",
"(",
"newBoolValue",
"(",
"target",
")",
")",
"\n",
"return",
"\n",
"}"
] |
// Bool makes this flag a boolean flag.
|
[
"Bool",
"makes",
"this",
"flag",
"a",
"boolean",
"flag",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/flags.go#L322-L326
|
148,060 |
alecthomas/kingpin
|
parsers.go
|
Bytes
|
func (p *parserMixin) Bytes() (target *units.Base2Bytes) {
target = new(units.Base2Bytes)
p.BytesVar(target)
return
}
|
go
|
func (p *parserMixin) Bytes() (target *units.Base2Bytes) {
target = new(units.Base2Bytes)
p.BytesVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Bytes",
"(",
")",
"(",
"target",
"*",
"units",
".",
"Base2Bytes",
")",
"{",
"target",
"=",
"new",
"(",
"units",
".",
"Base2Bytes",
")",
"\n",
"p",
".",
"BytesVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Bytes parses numeric byte units. eg. 1.5KB
|
[
"Bytes",
"parses",
"numeric",
"byte",
"units",
".",
"eg",
".",
"1",
".",
"5KB"
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L40-L44
|
148,061 |
alecthomas/kingpin
|
parsers.go
|
ExistingFile
|
func (p *parserMixin) ExistingFile() (target *string) {
target = new(string)
p.ExistingFileVar(target)
return
}
|
go
|
func (p *parserMixin) ExistingFile() (target *string) {
target = new(string)
p.ExistingFileVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"ExistingFile",
"(",
")",
"(",
"target",
"*",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"string",
")",
"\n",
"p",
".",
"ExistingFileVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// ExistingFile sets the parser to one that requires and returns an existing file.
|
[
"ExistingFile",
"sets",
"the",
"parser",
"to",
"one",
"that",
"requires",
"and",
"returns",
"an",
"existing",
"file",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L66-L70
|
148,062 |
alecthomas/kingpin
|
parsers.go
|
ExistingDir
|
func (p *parserMixin) ExistingDir() (target *string) {
target = new(string)
p.ExistingDirVar(target)
return
}
|
go
|
func (p *parserMixin) ExistingDir() (target *string) {
target = new(string)
p.ExistingDirVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"ExistingDir",
"(",
")",
"(",
"target",
"*",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"string",
")",
"\n",
"p",
".",
"ExistingDirVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// ExistingDir sets the parser to one that requires and returns an existing directory.
|
[
"ExistingDir",
"sets",
"the",
"parser",
"to",
"one",
"that",
"requires",
"and",
"returns",
"an",
"existing",
"directory",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L73-L77
|
148,063 |
alecthomas/kingpin
|
parsers.go
|
ExistingFileOrDir
|
func (p *parserMixin) ExistingFileOrDir() (target *string) {
target = new(string)
p.ExistingFileOrDirVar(target)
return
}
|
go
|
func (p *parserMixin) ExistingFileOrDir() (target *string) {
target = new(string)
p.ExistingFileOrDirVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"ExistingFileOrDir",
"(",
")",
"(",
"target",
"*",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"string",
")",
"\n",
"p",
".",
"ExistingFileOrDirVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// ExistingFileOrDir sets the parser to one that requires and returns an existing file OR directory.
|
[
"ExistingFileOrDir",
"sets",
"the",
"parser",
"to",
"one",
"that",
"requires",
"and",
"returns",
"an",
"existing",
"file",
"OR",
"directory",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L80-L84
|
148,064 |
alecthomas/kingpin
|
parsers.go
|
File
|
func (p *parserMixin) File() (target **os.File) {
target = new(*os.File)
p.FileVar(target)
return
}
|
go
|
func (p *parserMixin) File() (target **os.File) {
target = new(*os.File)
p.FileVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"File",
"(",
")",
"(",
"target",
"*",
"*",
"os",
".",
"File",
")",
"{",
"target",
"=",
"new",
"(",
"*",
"os",
".",
"File",
")",
"\n",
"p",
".",
"FileVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// File returns an os.File against an existing file.
|
[
"File",
"returns",
"an",
"os",
".",
"File",
"against",
"an",
"existing",
"file",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L87-L91
|
148,065 |
alecthomas/kingpin
|
parsers.go
|
BytesVar
|
func (p *parserMixin) BytesVar(target *units.Base2Bytes) {
p.SetValue(newBytesValue(target))
}
|
go
|
func (p *parserMixin) BytesVar(target *units.Base2Bytes) {
p.SetValue(newBytesValue(target))
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"BytesVar",
"(",
"target",
"*",
"units",
".",
"Base2Bytes",
")",
"{",
"p",
".",
"SetValue",
"(",
"newBytesValue",
"(",
"target",
")",
")",
"\n",
"}"
] |
// BytesVar parses numeric byte units. eg. 1.5KB
|
[
"BytesVar",
"parses",
"numeric",
"byte",
"units",
".",
"eg",
".",
"1",
".",
"5KB"
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L128-L130
|
148,066 |
alecthomas/kingpin
|
parsers.go
|
FileVar
|
func (p *parserMixin) FileVar(target **os.File) {
p.SetValue(newFileValue(target, os.O_RDONLY, 0))
}
|
go
|
func (p *parserMixin) FileVar(target **os.File) {
p.SetValue(newFileValue(target, os.O_RDONLY, 0))
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"FileVar",
"(",
"target",
"*",
"*",
"os",
".",
"File",
")",
"{",
"p",
".",
"SetValue",
"(",
"newFileValue",
"(",
"target",
",",
"os",
".",
"O_RDONLY",
",",
"0",
")",
")",
"\n",
"}"
] |
// FileVar opens an existing file.
|
[
"FileVar",
"opens",
"an",
"existing",
"file",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L153-L155
|
148,067 |
alecthomas/kingpin
|
parsers.go
|
URLList
|
func (p *parserMixin) URLList() (target *[]*url.URL) {
target = new([]*url.URL)
p.URLListVar(target)
return
}
|
go
|
func (p *parserMixin) URLList() (target *[]*url.URL) {
target = new([]*url.URL)
p.URLListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"URLList",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"*",
"url",
".",
"URL",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"*",
"url",
".",
"URL",
")",
"\n",
"p",
".",
"URLListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// URLList provides a parsed list of url.URL values.
|
[
"URLList",
"provides",
"a",
"parsed",
"list",
"of",
"url",
".",
"URL",
"values",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L168-L172
|
148,068 |
alecthomas/kingpin
|
parsers.go
|
URLListVar
|
func (p *parserMixin) URLListVar(target *[]*url.URL) {
p.SetValue(newURLListValue(target))
}
|
go
|
func (p *parserMixin) URLListVar(target *[]*url.URL) {
p.SetValue(newURLListValue(target))
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"URLListVar",
"(",
"target",
"*",
"[",
"]",
"*",
"url",
".",
"URL",
")",
"{",
"p",
".",
"SetValue",
"(",
"newURLListValue",
"(",
"target",
")",
")",
"\n",
"}"
] |
// URLListVar provides a parsed list of url.URL values.
|
[
"URLListVar",
"provides",
"a",
"parsed",
"list",
"of",
"url",
".",
"URL",
"values",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L175-L177
|
148,069 |
alecthomas/kingpin
|
parsers.go
|
Enum
|
func (p *parserMixin) Enum(options ...string) (target *string) {
target = new(string)
p.EnumVar(target, options...)
return
}
|
go
|
func (p *parserMixin) Enum(options ...string) (target *string) {
target = new(string)
p.EnumVar(target, options...)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Enum",
"(",
"options",
"...",
"string",
")",
"(",
"target",
"*",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"string",
")",
"\n",
"p",
".",
"EnumVar",
"(",
"target",
",",
"options",
"...",
")",
"\n",
"return",
"\n",
"}"
] |
// Enum allows a value from a set of options.
|
[
"Enum",
"allows",
"a",
"value",
"from",
"a",
"set",
"of",
"options",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L180-L184
|
148,070 |
alecthomas/kingpin
|
parsers.go
|
Enums
|
func (p *parserMixin) Enums(options ...string) (target *[]string) {
target = new([]string)
p.EnumsVar(target, options...)
return
}
|
go
|
func (p *parserMixin) Enums(options ...string) (target *[]string) {
target = new([]string)
p.EnumsVar(target, options...)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Enums",
"(",
"options",
"...",
"string",
")",
"(",
"target",
"*",
"[",
"]",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"string",
")",
"\n",
"p",
".",
"EnumsVar",
"(",
"target",
",",
"options",
"...",
")",
"\n",
"return",
"\n",
"}"
] |
// Enums allows a set of values from a set of options.
|
[
"Enums",
"allows",
"a",
"set",
"of",
"values",
"from",
"a",
"set",
"of",
"options",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L192-L196
|
148,071 |
alecthomas/kingpin
|
parsers.go
|
Counter
|
func (p *parserMixin) Counter() (target *int) {
target = new(int)
p.CounterVar(target)
return
}
|
go
|
func (p *parserMixin) Counter() (target *int) {
target = new(int)
p.CounterVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Counter",
"(",
")",
"(",
"target",
"*",
"int",
")",
"{",
"target",
"=",
"new",
"(",
"int",
")",
"\n",
"p",
".",
"CounterVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// A Counter increments a number each time it is encountered.
|
[
"A",
"Counter",
"increments",
"a",
"number",
"each",
"time",
"it",
"is",
"encountered",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/parsers.go#L204-L208
|
148,072 |
alecthomas/kingpin
|
values_generated.go
|
Bool
|
func (p *parserMixin) Bool() (target *bool) {
target = new(bool)
p.BoolVar(target)
return
}
|
go
|
func (p *parserMixin) Bool() (target *bool) {
target = new(bool)
p.BoolVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Bool",
"(",
")",
"(",
"target",
"*",
"bool",
")",
"{",
"target",
"=",
"new",
"(",
"bool",
")",
"\n",
"p",
".",
"BoolVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Bool parses the next command-line value as bool.
|
[
"Bool",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"bool",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L34-L38
|
148,073 |
alecthomas/kingpin
|
values_generated.go
|
BoolList
|
func (p *parserMixin) BoolList() (target *[]bool) {
target = new([]bool)
p.BoolListVar(target)
return
}
|
go
|
func (p *parserMixin) BoolList() (target *[]bool) {
target = new([]bool)
p.BoolListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"BoolList",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"bool",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"bool",
")",
"\n",
"p",
".",
"BoolListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// BoolList accumulates bool values into a slice.
|
[
"BoolList",
"accumulates",
"bool",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L45-L49
|
148,074 |
alecthomas/kingpin
|
values_generated.go
|
String
|
func (p *parserMixin) String() (target *string) {
target = new(string)
p.StringVar(target)
return
}
|
go
|
func (p *parserMixin) String() (target *string) {
target = new(string)
p.StringVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"String",
"(",
")",
"(",
"target",
"*",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"string",
")",
"\n",
"p",
".",
"StringVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// String parses the next command-line value as string.
|
[
"String",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"string",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L77-L81
|
148,075 |
alecthomas/kingpin
|
values_generated.go
|
Strings
|
func (p *parserMixin) Strings() (target *[]string) {
target = new([]string)
p.StringsVar(target)
return
}
|
go
|
func (p *parserMixin) Strings() (target *[]string) {
target = new([]string)
p.StringsVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Strings",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"string",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"string",
")",
"\n",
"p",
".",
"StringsVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Strings accumulates string values into a slice.
|
[
"Strings",
"accumulates",
"string",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L88-L92
|
148,076 |
alecthomas/kingpin
|
values_generated.go
|
Uint
|
func (p *parserMixin) Uint() (target *uint) {
target = new(uint)
p.UintVar(target)
return
}
|
go
|
func (p *parserMixin) Uint() (target *uint) {
target = new(uint)
p.UintVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint",
"(",
")",
"(",
"target",
"*",
"uint",
")",
"{",
"target",
"=",
"new",
"(",
"uint",
")",
"\n",
"p",
".",
"UintVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint parses the next command-line value as uint.
|
[
"Uint",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"uint",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L120-L124
|
148,077 |
alecthomas/kingpin
|
values_generated.go
|
Uints
|
func (p *parserMixin) Uints() (target *[]uint) {
target = new([]uint)
p.UintsVar(target)
return
}
|
go
|
func (p *parserMixin) Uints() (target *[]uint) {
target = new([]uint)
p.UintsVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uints",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"uint",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"uint",
")",
"\n",
"p",
".",
"UintsVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uints accumulates uint values into a slice.
|
[
"Uints",
"accumulates",
"uint",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L131-L135
|
148,078 |
alecthomas/kingpin
|
values_generated.go
|
Uint8
|
func (p *parserMixin) Uint8() (target *uint8) {
target = new(uint8)
p.Uint8Var(target)
return
}
|
go
|
func (p *parserMixin) Uint8() (target *uint8) {
target = new(uint8)
p.Uint8Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint8",
"(",
")",
"(",
"target",
"*",
"uint8",
")",
"{",
"target",
"=",
"new",
"(",
"uint8",
")",
"\n",
"p",
".",
"Uint8Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint8 parses the next command-line value as uint8.
|
[
"Uint8",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"uint8",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L163-L167
|
148,079 |
alecthomas/kingpin
|
values_generated.go
|
Uint8List
|
func (p *parserMixin) Uint8List() (target *[]uint8) {
target = new([]uint8)
p.Uint8ListVar(target)
return
}
|
go
|
func (p *parserMixin) Uint8List() (target *[]uint8) {
target = new([]uint8)
p.Uint8ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint8List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"uint8",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"uint8",
")",
"\n",
"p",
".",
"Uint8ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint8List accumulates uint8 values into a slice.
|
[
"Uint8List",
"accumulates",
"uint8",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L174-L178
|
148,080 |
alecthomas/kingpin
|
values_generated.go
|
Uint16
|
func (p *parserMixin) Uint16() (target *uint16) {
target = new(uint16)
p.Uint16Var(target)
return
}
|
go
|
func (p *parserMixin) Uint16() (target *uint16) {
target = new(uint16)
p.Uint16Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint16",
"(",
")",
"(",
"target",
"*",
"uint16",
")",
"{",
"target",
"=",
"new",
"(",
"uint16",
")",
"\n",
"p",
".",
"Uint16Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint16 parses the next command-line value as uint16.
|
[
"Uint16",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"uint16",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L206-L210
|
148,081 |
alecthomas/kingpin
|
values_generated.go
|
Uint16List
|
func (p *parserMixin) Uint16List() (target *[]uint16) {
target = new([]uint16)
p.Uint16ListVar(target)
return
}
|
go
|
func (p *parserMixin) Uint16List() (target *[]uint16) {
target = new([]uint16)
p.Uint16ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint16List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"uint16",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"uint16",
")",
"\n",
"p",
".",
"Uint16ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint16List accumulates uint16 values into a slice.
|
[
"Uint16List",
"accumulates",
"uint16",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L217-L221
|
148,082 |
alecthomas/kingpin
|
values_generated.go
|
Uint32
|
func (p *parserMixin) Uint32() (target *uint32) {
target = new(uint32)
p.Uint32Var(target)
return
}
|
go
|
func (p *parserMixin) Uint32() (target *uint32) {
target = new(uint32)
p.Uint32Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint32",
"(",
")",
"(",
"target",
"*",
"uint32",
")",
"{",
"target",
"=",
"new",
"(",
"uint32",
")",
"\n",
"p",
".",
"Uint32Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint32 parses the next command-line value as uint32.
|
[
"Uint32",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"uint32",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L249-L253
|
148,083 |
alecthomas/kingpin
|
values_generated.go
|
Uint32List
|
func (p *parserMixin) Uint32List() (target *[]uint32) {
target = new([]uint32)
p.Uint32ListVar(target)
return
}
|
go
|
func (p *parserMixin) Uint32List() (target *[]uint32) {
target = new([]uint32)
p.Uint32ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint32List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"uint32",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"uint32",
")",
"\n",
"p",
".",
"Uint32ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint32List accumulates uint32 values into a slice.
|
[
"Uint32List",
"accumulates",
"uint32",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L260-L264
|
148,084 |
alecthomas/kingpin
|
values_generated.go
|
Uint64
|
func (p *parserMixin) Uint64() (target *uint64) {
target = new(uint64)
p.Uint64Var(target)
return
}
|
go
|
func (p *parserMixin) Uint64() (target *uint64) {
target = new(uint64)
p.Uint64Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint64",
"(",
")",
"(",
"target",
"*",
"uint64",
")",
"{",
"target",
"=",
"new",
"(",
"uint64",
")",
"\n",
"p",
".",
"Uint64Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint64 parses the next command-line value as uint64.
|
[
"Uint64",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"uint64",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L292-L296
|
148,085 |
alecthomas/kingpin
|
values_generated.go
|
Uint64List
|
func (p *parserMixin) Uint64List() (target *[]uint64) {
target = new([]uint64)
p.Uint64ListVar(target)
return
}
|
go
|
func (p *parserMixin) Uint64List() (target *[]uint64) {
target = new([]uint64)
p.Uint64ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Uint64List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"uint64",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"uint64",
")",
"\n",
"p",
".",
"Uint64ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Uint64List accumulates uint64 values into a slice.
|
[
"Uint64List",
"accumulates",
"uint64",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L303-L307
|
148,086 |
alecthomas/kingpin
|
values_generated.go
|
Int
|
func (p *parserMixin) Int() (target *int) {
target = new(int)
p.IntVar(target)
return
}
|
go
|
func (p *parserMixin) Int() (target *int) {
target = new(int)
p.IntVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int",
"(",
")",
"(",
"target",
"*",
"int",
")",
"{",
"target",
"=",
"new",
"(",
"int",
")",
"\n",
"p",
".",
"IntVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int parses the next command-line value as int.
|
[
"Int",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"int",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L335-L339
|
148,087 |
alecthomas/kingpin
|
values_generated.go
|
Ints
|
func (p *parserMixin) Ints() (target *[]int) {
target = new([]int)
p.IntsVar(target)
return
}
|
go
|
func (p *parserMixin) Ints() (target *[]int) {
target = new([]int)
p.IntsVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Ints",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"int",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"int",
")",
"\n",
"p",
".",
"IntsVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Ints accumulates int values into a slice.
|
[
"Ints",
"accumulates",
"int",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L346-L350
|
148,088 |
alecthomas/kingpin
|
values_generated.go
|
Int8
|
func (p *parserMixin) Int8() (target *int8) {
target = new(int8)
p.Int8Var(target)
return
}
|
go
|
func (p *parserMixin) Int8() (target *int8) {
target = new(int8)
p.Int8Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int8",
"(",
")",
"(",
"target",
"*",
"int8",
")",
"{",
"target",
"=",
"new",
"(",
"int8",
")",
"\n",
"p",
".",
"Int8Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int8 parses the next command-line value as int8.
|
[
"Int8",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"int8",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L378-L382
|
148,089 |
alecthomas/kingpin
|
values_generated.go
|
Int8List
|
func (p *parserMixin) Int8List() (target *[]int8) {
target = new([]int8)
p.Int8ListVar(target)
return
}
|
go
|
func (p *parserMixin) Int8List() (target *[]int8) {
target = new([]int8)
p.Int8ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int8List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"int8",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"int8",
")",
"\n",
"p",
".",
"Int8ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int8List accumulates int8 values into a slice.
|
[
"Int8List",
"accumulates",
"int8",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L389-L393
|
148,090 |
alecthomas/kingpin
|
values_generated.go
|
Int16
|
func (p *parserMixin) Int16() (target *int16) {
target = new(int16)
p.Int16Var(target)
return
}
|
go
|
func (p *parserMixin) Int16() (target *int16) {
target = new(int16)
p.Int16Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int16",
"(",
")",
"(",
"target",
"*",
"int16",
")",
"{",
"target",
"=",
"new",
"(",
"int16",
")",
"\n",
"p",
".",
"Int16Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int16 parses the next command-line value as int16.
|
[
"Int16",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"int16",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L421-L425
|
148,091 |
alecthomas/kingpin
|
values_generated.go
|
Int16List
|
func (p *parserMixin) Int16List() (target *[]int16) {
target = new([]int16)
p.Int16ListVar(target)
return
}
|
go
|
func (p *parserMixin) Int16List() (target *[]int16) {
target = new([]int16)
p.Int16ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int16List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"int16",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"int16",
")",
"\n",
"p",
".",
"Int16ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int16List accumulates int16 values into a slice.
|
[
"Int16List",
"accumulates",
"int16",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L432-L436
|
148,092 |
alecthomas/kingpin
|
values_generated.go
|
Int32
|
func (p *parserMixin) Int32() (target *int32) {
target = new(int32)
p.Int32Var(target)
return
}
|
go
|
func (p *parserMixin) Int32() (target *int32) {
target = new(int32)
p.Int32Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int32",
"(",
")",
"(",
"target",
"*",
"int32",
")",
"{",
"target",
"=",
"new",
"(",
"int32",
")",
"\n",
"p",
".",
"Int32Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int32 parses the next command-line value as int32.
|
[
"Int32",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"int32",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L464-L468
|
148,093 |
alecthomas/kingpin
|
values_generated.go
|
Int32List
|
func (p *parserMixin) Int32List() (target *[]int32) {
target = new([]int32)
p.Int32ListVar(target)
return
}
|
go
|
func (p *parserMixin) Int32List() (target *[]int32) {
target = new([]int32)
p.Int32ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int32List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"int32",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"int32",
")",
"\n",
"p",
".",
"Int32ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int32List accumulates int32 values into a slice.
|
[
"Int32List",
"accumulates",
"int32",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L475-L479
|
148,094 |
alecthomas/kingpin
|
values_generated.go
|
Int64
|
func (p *parserMixin) Int64() (target *int64) {
target = new(int64)
p.Int64Var(target)
return
}
|
go
|
func (p *parserMixin) Int64() (target *int64) {
target = new(int64)
p.Int64Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int64",
"(",
")",
"(",
"target",
"*",
"int64",
")",
"{",
"target",
"=",
"new",
"(",
"int64",
")",
"\n",
"p",
".",
"Int64Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int64 parses the next command-line value as int64.
|
[
"Int64",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"int64",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L507-L511
|
148,095 |
alecthomas/kingpin
|
values_generated.go
|
Int64List
|
func (p *parserMixin) Int64List() (target *[]int64) {
target = new([]int64)
p.Int64ListVar(target)
return
}
|
go
|
func (p *parserMixin) Int64List() (target *[]int64) {
target = new([]int64)
p.Int64ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Int64List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"int64",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"int64",
")",
"\n",
"p",
".",
"Int64ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Int64List accumulates int64 values into a slice.
|
[
"Int64List",
"accumulates",
"int64",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L518-L522
|
148,096 |
alecthomas/kingpin
|
values_generated.go
|
Float64
|
func (p *parserMixin) Float64() (target *float64) {
target = new(float64)
p.Float64Var(target)
return
}
|
go
|
func (p *parserMixin) Float64() (target *float64) {
target = new(float64)
p.Float64Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Float64",
"(",
")",
"(",
"target",
"*",
"float64",
")",
"{",
"target",
"=",
"new",
"(",
"float64",
")",
"\n",
"p",
".",
"Float64Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Float64 parses the next command-line value as float64.
|
[
"Float64",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"float64",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L550-L554
|
148,097 |
alecthomas/kingpin
|
values_generated.go
|
Float64List
|
func (p *parserMixin) Float64List() (target *[]float64) {
target = new([]float64)
p.Float64ListVar(target)
return
}
|
go
|
func (p *parserMixin) Float64List() (target *[]float64) {
target = new([]float64)
p.Float64ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Float64List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"float64",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"float64",
")",
"\n",
"p",
".",
"Float64ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Float64List accumulates float64 values into a slice.
|
[
"Float64List",
"accumulates",
"float64",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L561-L565
|
148,098 |
alecthomas/kingpin
|
values_generated.go
|
Float32
|
func (p *parserMixin) Float32() (target *float32) {
target = new(float32)
p.Float32Var(target)
return
}
|
go
|
func (p *parserMixin) Float32() (target *float32) {
target = new(float32)
p.Float32Var(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Float32",
"(",
")",
"(",
"target",
"*",
"float32",
")",
"{",
"target",
"=",
"new",
"(",
"float32",
")",
"\n",
"p",
".",
"Float32Var",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Float32 parses the next command-line value as float32.
|
[
"Float32",
"parses",
"the",
"next",
"command",
"-",
"line",
"value",
"as",
"float32",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L593-L597
|
148,099 |
alecthomas/kingpin
|
values_generated.go
|
Float32List
|
func (p *parserMixin) Float32List() (target *[]float32) {
target = new([]float32)
p.Float32ListVar(target)
return
}
|
go
|
func (p *parserMixin) Float32List() (target *[]float32) {
target = new([]float32)
p.Float32ListVar(target)
return
}
|
[
"func",
"(",
"p",
"*",
"parserMixin",
")",
"Float32List",
"(",
")",
"(",
"target",
"*",
"[",
"]",
"float32",
")",
"{",
"target",
"=",
"new",
"(",
"[",
"]",
"float32",
")",
"\n",
"p",
".",
"Float32ListVar",
"(",
"target",
")",
"\n",
"return",
"\n",
"}"
] |
// Float32List accumulates float32 values into a slice.
|
[
"Float32List",
"accumulates",
"float32",
"values",
"into",
"a",
"slice",
"."
] |
ef6e7c151c4fdbd3fe78aad001729fee08fa0932
|
https://github.com/alecthomas/kingpin/blob/ef6e7c151c4fdbd3fe78aad001729fee08fa0932/values_generated.go#L604-L608
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.