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
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
9,900 | koding/cache | lfu_nots.go | NewLFUNoTS | func NewLFUNoTS(size int) Cache {
if size < 1 {
panic("invalid cache size")
}
return &LFUNoTS{
frequencyList: list.New(),
cache: NewMemoryNoTS(),
size: size,
currentSize: 0,
}
} | go | func NewLFUNoTS(size int) Cache {
if size < 1 {
panic("invalid cache size")
}
return &LFUNoTS{
frequencyList: list.New(),
cache: NewMemoryNoTS(),
size: size,
currentSize: 0,
}
} | [
"func",
"NewLFUNoTS",
"(",
"size",
"int",
")",
"Cache",
"{",
"if",
"size",
"<",
"1",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"LFUNoTS",
"{",
"frequencyList",
":",
"list",
".",
"New",
"(",
")",
",",
"cache",
":",
"NewMemoryNoTS",
"(",
")",
",",
"size",
":",
"size",
",",
"currentSize",
":",
"0",
",",
"}",
"\n",
"}"
] | // NewLFUNoTS creates a new LFU cache struct for further cache operations. Size
// is used for limiting the upper bound of the cache | [
"NewLFUNoTS",
"creates",
"a",
"new",
"LFU",
"cache",
"struct",
"for",
"further",
"cache",
"operations",
".",
"Size",
"is",
"used",
"for",
"limiting",
"the",
"upper",
"bound",
"of",
"the",
"cache"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L38-L49 |
9,901 | koding/cache | lfu_nots.go | Get | func (l *LFUNoTS) Get(key string) (interface{}, error) {
res, err := l.cache.Get(key)
if err != nil {
return nil, err
}
ci := res.(*cacheItem)
// increase usage of cache item
l.incr(ci)
return ci.v, nil
} | go | func (l *LFUNoTS) Get(key string) (interface{}, error) {
res, err := l.cache.Get(key)
if err != nil {
return nil, err
}
ci := res.(*cacheItem)
// increase usage of cache item
l.incr(ci)
return ci.v, nil
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"l",
".",
"cache",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"ci",
":=",
"res",
".",
"(",
"*",
"cacheItem",
")",
"\n\n",
"// increase usage of cache item",
"l",
".",
"incr",
"(",
"ci",
")",
"\n",
"return",
"ci",
".",
"v",
",",
"nil",
"\n",
"}"
] | // Get gets value of cache item
// then increments the usage of the item | [
"Get",
"gets",
"value",
"of",
"cache",
"item",
"then",
"increments",
"the",
"usage",
"of",
"the",
"item"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L53-L64 |
9,902 | koding/cache | lfu_nots.go | Delete | func (l *LFUNoTS) Delete(key string) error {
res, err := l.cache.Get(key)
if err != nil && err != ErrNotFound {
return err
}
// we dont need to delete if already doesn't exist
if err == ErrNotFound {
return nil
}
ci := res.(*cacheItem)
l.remove(ci, ci.freqElement)
l.currentSize--
return l.cache.Delete(key)
} | go | func (l *LFUNoTS) Delete(key string) error {
res, err := l.cache.Get(key)
if err != nil && err != ErrNotFound {
return err
}
// we dont need to delete if already doesn't exist
if err == ErrNotFound {
return nil
}
ci := res.(*cacheItem)
l.remove(ci, ci.freqElement)
l.currentSize--
return l.cache.Delete(key)
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"Delete",
"(",
"key",
"string",
")",
"error",
"{",
"res",
",",
"err",
":=",
"l",
".",
"cache",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"ErrNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// we dont need to delete if already doesn't exist",
"if",
"err",
"==",
"ErrNotFound",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"ci",
":=",
"res",
".",
"(",
"*",
"cacheItem",
")",
"\n\n",
"l",
".",
"remove",
"(",
"ci",
",",
"ci",
".",
"freqElement",
")",
"\n",
"l",
".",
"currentSize",
"--",
"\n",
"return",
"l",
".",
"cache",
".",
"Delete",
"(",
"key",
")",
"\n",
"}"
] | // Delete deletes the key and its dependencies | [
"Delete",
"deletes",
"the",
"key",
"and",
"its",
"dependencies"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L80-L96 |
9,903 | koding/cache | lfu_nots.go | set | func (l *LFUNoTS) set(key string, value interface{}) error {
res, err := l.cache.Get(key)
if err != nil && err != ErrNotFound {
return err
}
if err == ErrNotFound {
//create new cache item
ci := newCacheItem(key, value)
// if cache size si reached to max size
// then first remove lfu item from the list
if l.currentSize >= l.size {
// then evict some data from head of linked list.
l.evict(l.frequencyList.Front())
}
l.cache.Set(key, ci)
l.incr(ci)
} else {
//update existing one
val := res.(*cacheItem)
val.v = value
l.cache.Set(key, val)
l.incr(res.(*cacheItem))
}
return nil
} | go | func (l *LFUNoTS) set(key string, value interface{}) error {
res, err := l.cache.Get(key)
if err != nil && err != ErrNotFound {
return err
}
if err == ErrNotFound {
//create new cache item
ci := newCacheItem(key, value)
// if cache size si reached to max size
// then first remove lfu item from the list
if l.currentSize >= l.size {
// then evict some data from head of linked list.
l.evict(l.frequencyList.Front())
}
l.cache.Set(key, ci)
l.incr(ci)
} else {
//update existing one
val := res.(*cacheItem)
val.v = value
l.cache.Set(key, val)
l.incr(res.(*cacheItem))
}
return nil
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"set",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"error",
"{",
"res",
",",
"err",
":=",
"l",
".",
"cache",
".",
"Get",
"(",
"key",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"ErrNotFound",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
"==",
"ErrNotFound",
"{",
"//create new cache item",
"ci",
":=",
"newCacheItem",
"(",
"key",
",",
"value",
")",
"\n\n",
"// if cache size si reached to max size",
"// then first remove lfu item from the list",
"if",
"l",
".",
"currentSize",
">=",
"l",
".",
"size",
"{",
"// then evict some data from head of linked list.",
"l",
".",
"evict",
"(",
"l",
".",
"frequencyList",
".",
"Front",
"(",
")",
")",
"\n",
"}",
"\n\n",
"l",
".",
"cache",
".",
"Set",
"(",
"key",
",",
"ci",
")",
"\n",
"l",
".",
"incr",
"(",
"ci",
")",
"\n\n",
"}",
"else",
"{",
"//update existing one",
"val",
":=",
"res",
".",
"(",
"*",
"cacheItem",
")",
"\n",
"val",
".",
"v",
"=",
"value",
"\n",
"l",
".",
"cache",
".",
"Set",
"(",
"key",
",",
"val",
")",
"\n",
"l",
".",
"incr",
"(",
"res",
".",
"(",
"*",
"cacheItem",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // set sets a new key-value pair | [
"set",
"sets",
"a",
"new",
"key",
"-",
"value",
"pair"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L99-L128 |
9,904 | koding/cache | lfu_nots.go | incr | func (l *LFUNoTS) incr(ci *cacheItem) {
var nextValue int
var nextPosition *list.Element
// update existing one
if ci.freqElement != nil {
nextValue = ci.freqElement.Value.(*entry).freqCount + 1
// replace the position of frequency element
nextPosition = ci.freqElement.Next()
} else {
// create new frequency element for cache item
// ci.freqElement is nil so next value of freq will be 1
nextValue = 1
// we created new element and its position will be head of linked list
nextPosition = l.frequencyList.Front()
l.currentSize++
}
// we need to check position first, otherwise it will panic if we try to fetch value of entry
if nextPosition == nil || nextPosition.Value.(*entry).freqCount != nextValue {
// create new entry node for linked list
entry := newEntry(nextValue)
if ci.freqElement == nil {
nextPosition = l.frequencyList.PushFront(entry)
} else {
nextPosition = l.frequencyList.InsertAfter(entry, ci.freqElement)
}
}
nextPosition.Value.(*entry).listEntry[ci] = struct{}{}
ci.freqElement = nextPosition
// we have moved the cache item to the next position,
// then we need to remove old position of the cacheItem from the list
// then we deleted previous position of cacheItem
if ci.freqElement.Prev() != nil {
l.remove(ci, ci.freqElement.Prev())
}
} | go | func (l *LFUNoTS) incr(ci *cacheItem) {
var nextValue int
var nextPosition *list.Element
// update existing one
if ci.freqElement != nil {
nextValue = ci.freqElement.Value.(*entry).freqCount + 1
// replace the position of frequency element
nextPosition = ci.freqElement.Next()
} else {
// create new frequency element for cache item
// ci.freqElement is nil so next value of freq will be 1
nextValue = 1
// we created new element and its position will be head of linked list
nextPosition = l.frequencyList.Front()
l.currentSize++
}
// we need to check position first, otherwise it will panic if we try to fetch value of entry
if nextPosition == nil || nextPosition.Value.(*entry).freqCount != nextValue {
// create new entry node for linked list
entry := newEntry(nextValue)
if ci.freqElement == nil {
nextPosition = l.frequencyList.PushFront(entry)
} else {
nextPosition = l.frequencyList.InsertAfter(entry, ci.freqElement)
}
}
nextPosition.Value.(*entry).listEntry[ci] = struct{}{}
ci.freqElement = nextPosition
// we have moved the cache item to the next position,
// then we need to remove old position of the cacheItem from the list
// then we deleted previous position of cacheItem
if ci.freqElement.Prev() != nil {
l.remove(ci, ci.freqElement.Prev())
}
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"incr",
"(",
"ci",
"*",
"cacheItem",
")",
"{",
"var",
"nextValue",
"int",
"\n",
"var",
"nextPosition",
"*",
"list",
".",
"Element",
"\n",
"// update existing one",
"if",
"ci",
".",
"freqElement",
"!=",
"nil",
"{",
"nextValue",
"=",
"ci",
".",
"freqElement",
".",
"Value",
".",
"(",
"*",
"entry",
")",
".",
"freqCount",
"+",
"1",
"\n",
"// replace the position of frequency element",
"nextPosition",
"=",
"ci",
".",
"freqElement",
".",
"Next",
"(",
")",
"\n",
"}",
"else",
"{",
"// create new frequency element for cache item",
"// ci.freqElement is nil so next value of freq will be 1",
"nextValue",
"=",
"1",
"\n",
"// we created new element and its position will be head of linked list",
"nextPosition",
"=",
"l",
".",
"frequencyList",
".",
"Front",
"(",
")",
"\n",
"l",
".",
"currentSize",
"++",
"\n",
"}",
"\n\n",
"// we need to check position first, otherwise it will panic if we try to fetch value of entry",
"if",
"nextPosition",
"==",
"nil",
"||",
"nextPosition",
".",
"Value",
".",
"(",
"*",
"entry",
")",
".",
"freqCount",
"!=",
"nextValue",
"{",
"// create new entry node for linked list",
"entry",
":=",
"newEntry",
"(",
"nextValue",
")",
"\n",
"if",
"ci",
".",
"freqElement",
"==",
"nil",
"{",
"nextPosition",
"=",
"l",
".",
"frequencyList",
".",
"PushFront",
"(",
"entry",
")",
"\n",
"}",
"else",
"{",
"nextPosition",
"=",
"l",
".",
"frequencyList",
".",
"InsertAfter",
"(",
"entry",
",",
"ci",
".",
"freqElement",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"nextPosition",
".",
"Value",
".",
"(",
"*",
"entry",
")",
".",
"listEntry",
"[",
"ci",
"]",
"=",
"struct",
"{",
"}",
"{",
"}",
"\n",
"ci",
".",
"freqElement",
"=",
"nextPosition",
"\n\n",
"// we have moved the cache item to the next position,",
"// then we need to remove old position of the cacheItem from the list",
"// then we deleted previous position of cacheItem",
"if",
"ci",
".",
"freqElement",
".",
"Prev",
"(",
")",
"!=",
"nil",
"{",
"l",
".",
"remove",
"(",
"ci",
",",
"ci",
".",
"freqElement",
".",
"Prev",
"(",
")",
")",
"\n",
"}",
"\n",
"}"
] | // incr increments the usage of cache items
// incrementing will be used in 'Get' & 'Set' functions
// whenever these functions are used, usage count of any key
// will be increased | [
"incr",
"increments",
"the",
"usage",
"of",
"cache",
"items",
"incrementing",
"will",
"be",
"used",
"in",
"Get",
"&",
"Set",
"functions",
"whenever",
"these",
"functions",
"are",
"used",
"usage",
"count",
"of",
"any",
"key",
"will",
"be",
"increased"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L143-L180 |
9,905 | koding/cache | lfu_nots.go | remove | func (l *LFUNoTS) remove(ci *cacheItem, position *list.Element) {
entry := position.Value.(*entry).listEntry
delete(entry, ci)
if len(entry) == 0 {
l.frequencyList.Remove(position)
}
} | go | func (l *LFUNoTS) remove(ci *cacheItem, position *list.Element) {
entry := position.Value.(*entry).listEntry
delete(entry, ci)
if len(entry) == 0 {
l.frequencyList.Remove(position)
}
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"remove",
"(",
"ci",
"*",
"cacheItem",
",",
"position",
"*",
"list",
".",
"Element",
")",
"{",
"entry",
":=",
"position",
".",
"Value",
".",
"(",
"*",
"entry",
")",
".",
"listEntry",
"\n",
"delete",
"(",
"entry",
",",
"ci",
")",
"\n",
"if",
"len",
"(",
"entry",
")",
"==",
"0",
"{",
"l",
".",
"frequencyList",
".",
"Remove",
"(",
"position",
")",
"\n",
"}",
"\n",
"}"
] | // remove removes the cache item from the cache list
// after deleting key from the list, if its linked list has no any item no longer
// then that linked list elemnet will be removed from the list too | [
"remove",
"removes",
"the",
"cache",
"item",
"from",
"the",
"cache",
"list",
"after",
"deleting",
"key",
"from",
"the",
"list",
"if",
"its",
"linked",
"list",
"has",
"no",
"any",
"item",
"no",
"longer",
"then",
"that",
"linked",
"list",
"elemnet",
"will",
"be",
"removed",
"from",
"the",
"list",
"too"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L185-L191 |
9,906 | koding/cache | lfu_nots.go | evict | func (l *LFUNoTS) evict(e *list.Element) error {
// ne need to return err if list element is already nil
if e == nil {
return nil
}
// remove the first item of the linked list
for entry := range e.Value.(*entry).listEntry {
l.cache.Delete(entry.k)
l.remove(entry, e)
l.currentSize--
break
}
return nil
} | go | func (l *LFUNoTS) evict(e *list.Element) error {
// ne need to return err if list element is already nil
if e == nil {
return nil
}
// remove the first item of the linked list
for entry := range e.Value.(*entry).listEntry {
l.cache.Delete(entry.k)
l.remove(entry, e)
l.currentSize--
break
}
return nil
} | [
"func",
"(",
"l",
"*",
"LFUNoTS",
")",
"evict",
"(",
"e",
"*",
"list",
".",
"Element",
")",
"error",
"{",
"// ne need to return err if list element is already nil",
"if",
"e",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// remove the first item of the linked list",
"for",
"entry",
":=",
"range",
"e",
".",
"Value",
".",
"(",
"*",
"entry",
")",
".",
"listEntry",
"{",
"l",
".",
"cache",
".",
"Delete",
"(",
"entry",
".",
"k",
")",
"\n",
"l",
".",
"remove",
"(",
"entry",
",",
"e",
")",
"\n",
"l",
".",
"currentSize",
"--",
"\n",
"break",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // evict deletes the element from list with given linked list element | [
"evict",
"deletes",
"the",
"element",
"from",
"list",
"with",
"given",
"linked",
"list",
"element"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L194-L209 |
9,907 | koding/cache | lfu_nots.go | newEntry | func newEntry(freqCount int) *entry {
return &entry{
freqCount: freqCount,
listEntry: make(map[*cacheItem]struct{}),
}
} | go | func newEntry(freqCount int) *entry {
return &entry{
freqCount: freqCount,
listEntry: make(map[*cacheItem]struct{}),
}
} | [
"func",
"newEntry",
"(",
"freqCount",
"int",
")",
"*",
"entry",
"{",
"return",
"&",
"entry",
"{",
"freqCount",
":",
"freqCount",
",",
"listEntry",
":",
"make",
"(",
"map",
"[",
"*",
"cacheItem",
"]",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // newEntry creates a new entry with frequency count | [
"newEntry",
"creates",
"a",
"new",
"entry",
"with",
"frequency",
"count"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L212-L217 |
9,908 | koding/cache | lfu_nots.go | newCacheItem | func newCacheItem(key string, value interface{}) *cacheItem {
return &cacheItem{
k: key,
v: value,
}
} | go | func newCacheItem(key string, value interface{}) *cacheItem {
return &cacheItem{
k: key,
v: value,
}
} | [
"func",
"newCacheItem",
"(",
"key",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"*",
"cacheItem",
"{",
"return",
"&",
"cacheItem",
"{",
"k",
":",
"key",
",",
"v",
":",
"value",
",",
"}",
"\n\n",
"}"
] | // newCacheItem creates a new cache item with key and value | [
"newCacheItem",
"creates",
"a",
"new",
"cache",
"item",
"with",
"key",
"and",
"value"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/lfu_nots.go#L220-L226 |
9,909 | koding/cache | memory_ttl.go | NewMemoryWithTTL | func NewMemoryWithTTL(ttl time.Duration) *MemoryTTL {
return &MemoryTTL{
cache: NewMemoryNoTS(),
setAts: map[string]time.Time{},
ttl: ttl,
}
} | go | func NewMemoryWithTTL(ttl time.Duration) *MemoryTTL {
return &MemoryTTL{
cache: NewMemoryNoTS(),
setAts: map[string]time.Time{},
ttl: ttl,
}
} | [
"func",
"NewMemoryWithTTL",
"(",
"ttl",
"time",
".",
"Duration",
")",
"*",
"MemoryTTL",
"{",
"return",
"&",
"MemoryTTL",
"{",
"cache",
":",
"NewMemoryNoTS",
"(",
")",
",",
"setAts",
":",
"map",
"[",
"string",
"]",
"time",
".",
"Time",
"{",
"}",
",",
"ttl",
":",
"ttl",
",",
"}",
"\n",
"}"
] | // NewMemoryWithTTL creates an inmemory cache system
// Which everytime will return the true values about a cache hit
// and never will leak memory
// ttl is used for expiration of a key from cache | [
"NewMemoryWithTTL",
"creates",
"an",
"inmemory",
"cache",
"system",
"Which",
"everytime",
"will",
"return",
"the",
"true",
"values",
"about",
"a",
"cache",
"hit",
"and",
"never",
"will",
"leak",
"memory",
"ttl",
"is",
"used",
"for",
"expiration",
"of",
"a",
"key",
"from",
"cache"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/memory_ttl.go#L37-L43 |
9,910 | koding/cache | sharded_ttl.go | NewShardedCacheWithTTL | func NewShardedCacheWithTTL(ttl time.Duration, f func() Cache) *ShardedTTL {
return &ShardedTTL{
cache: NewShardedNoTS(f),
setAts: map[string]map[string]time.Time{},
ttl: ttl,
}
} | go | func NewShardedCacheWithTTL(ttl time.Duration, f func() Cache) *ShardedTTL {
return &ShardedTTL{
cache: NewShardedNoTS(f),
setAts: map[string]map[string]time.Time{},
ttl: ttl,
}
} | [
"func",
"NewShardedCacheWithTTL",
"(",
"ttl",
"time",
".",
"Duration",
",",
"f",
"func",
"(",
")",
"Cache",
")",
"*",
"ShardedTTL",
"{",
"return",
"&",
"ShardedTTL",
"{",
"cache",
":",
"NewShardedNoTS",
"(",
"f",
")",
",",
"setAts",
":",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"time",
".",
"Time",
"{",
"}",
",",
"ttl",
":",
"ttl",
",",
"}",
"\n",
"}"
] | // NewShardedCacheWithTTL creates a sharded cache system with TTL based on specified Cache constructor
// Which everytime will return the true values about a cache hit
// and never will leak memory
// ttl is used for expiration of a key from cache | [
"NewShardedCacheWithTTL",
"creates",
"a",
"sharded",
"cache",
"system",
"with",
"TTL",
"based",
"on",
"specified",
"Cache",
"constructor",
"Which",
"everytime",
"will",
"return",
"the",
"true",
"values",
"about",
"a",
"cache",
"hit",
"and",
"never",
"will",
"leak",
"memory",
"ttl",
"is",
"used",
"for",
"expiration",
"of",
"a",
"key",
"from",
"cache"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/sharded_ttl.go#L32-L38 |
9,911 | koding/cache | sharded_ttl.go | DeleteShard | func (r *ShardedTTL) DeleteShard(tenantID string) error {
r.Lock()
defer r.Unlock()
_, ok := r.setAts[tenantID]
if ok {
for key := range r.setAts[tenantID] {
r.delete(tenantID, key)
}
}
return nil
} | go | func (r *ShardedTTL) DeleteShard(tenantID string) error {
r.Lock()
defer r.Unlock()
_, ok := r.setAts[tenantID]
if ok {
for key := range r.setAts[tenantID] {
r.delete(tenantID, key)
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"ShardedTTL",
")",
"DeleteShard",
"(",
"tenantID",
"string",
")",
"error",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"_",
",",
"ok",
":=",
"r",
".",
"setAts",
"[",
"tenantID",
"]",
"\n",
"if",
"ok",
"{",
"for",
"key",
":=",
"range",
"r",
".",
"setAts",
"[",
"tenantID",
"]",
"{",
"r",
".",
"delete",
"(",
"tenantID",
",",
"key",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeleteShard deletes with given tenantID without key | [
"DeleteShard",
"deletes",
"with",
"given",
"tenantID",
"without",
"key"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/sharded_ttl.go#L137-L148 |
9,912 | koding/cache | mongo_model.go | get | func (m *MongoCache) get(key string) (*Document, error) {
keyValue := new(Document)
query := func(c *mgo.Collection) error {
return c.Find(bson.M{
"_id": key,
"expireAt": bson.M{
"$gt": time.Now().UTC(),
}}).One(&keyValue)
}
err := m.run(m.CollectionName, query)
if err != nil {
return nil, err
}
return keyValue, nil
} | go | func (m *MongoCache) get(key string) (*Document, error) {
keyValue := new(Document)
query := func(c *mgo.Collection) error {
return c.Find(bson.M{
"_id": key,
"expireAt": bson.M{
"$gt": time.Now().UTC(),
}}).One(&keyValue)
}
err := m.run(m.CollectionName, query)
if err != nil {
return nil, err
}
return keyValue, nil
} | [
"func",
"(",
"m",
"*",
"MongoCache",
")",
"get",
"(",
"key",
"string",
")",
"(",
"*",
"Document",
",",
"error",
")",
"{",
"keyValue",
":=",
"new",
"(",
"Document",
")",
"\n\n",
"query",
":=",
"func",
"(",
"c",
"*",
"mgo",
".",
"Collection",
")",
"error",
"{",
"return",
"c",
".",
"Find",
"(",
"bson",
".",
"M",
"{",
"\"",
"\"",
":",
"key",
",",
"\"",
"\"",
":",
"bson",
".",
"M",
"{",
"\"",
"\"",
":",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
",",
"}",
"}",
")",
".",
"One",
"(",
"&",
"keyValue",
")",
"\n",
"}",
"\n\n",
"err",
":=",
"m",
".",
"run",
"(",
"m",
".",
"CollectionName",
",",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"keyValue",
",",
"nil",
"\n",
"}"
] | // getKey fetches the key with its key | [
"getKey",
"fetches",
"the",
"key",
"with",
"its",
"key"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/mongo_model.go#L18-L35 |
9,913 | koding/cache | mongo_model.go | delete | func (m *MongoCache) delete(key string) error {
query := func(c *mgo.Collection) error {
err := c.RemoveId(key)
return err
}
return m.run(m.CollectionName, query)
} | go | func (m *MongoCache) delete(key string) error {
query := func(c *mgo.Collection) error {
err := c.RemoveId(key)
return err
}
return m.run(m.CollectionName, query)
} | [
"func",
"(",
"m",
"*",
"MongoCache",
")",
"delete",
"(",
"key",
"string",
")",
"error",
"{",
"query",
":=",
"func",
"(",
"c",
"*",
"mgo",
".",
"Collection",
")",
"error",
"{",
"err",
":=",
"c",
".",
"RemoveId",
"(",
"key",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"m",
".",
"run",
"(",
"m",
".",
"CollectionName",
",",
"query",
")",
"\n",
"}"
] | // deleteKey removes the key-value from mongoDB | [
"deleteKey",
"removes",
"the",
"key",
"-",
"value",
"from",
"mongoDB"
] | e8a81b0b3f20f895153311abde1062894b5912d6 | https://github.com/koding/cache/blob/e8a81b0b3f20f895153311abde1062894b5912d6/mongo_model.go#L53-L60 |
9,914 | docker/leadership | candidate.go | NewCandidate | func NewCandidate(client store.Store, key, node string, ttl time.Duration) *Candidate {
return &Candidate{
client: client,
key: key,
node: node,
leader: false,
lockTTL: ttl,
resignCh: make(chan bool),
stopCh: make(chan struct{}),
}
} | go | func NewCandidate(client store.Store, key, node string, ttl time.Duration) *Candidate {
return &Candidate{
client: client,
key: key,
node: node,
leader: false,
lockTTL: ttl,
resignCh: make(chan bool),
stopCh: make(chan struct{}),
}
} | [
"func",
"NewCandidate",
"(",
"client",
"store",
".",
"Store",
",",
"key",
",",
"node",
"string",
",",
"ttl",
"time",
".",
"Duration",
")",
"*",
"Candidate",
"{",
"return",
"&",
"Candidate",
"{",
"client",
":",
"client",
",",
"key",
":",
"key",
",",
"node",
":",
"node",
",",
"leader",
":",
"false",
",",
"lockTTL",
":",
"ttl",
",",
"resignCh",
":",
"make",
"(",
"chan",
"bool",
")",
",",
"stopCh",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // NewCandidate creates a new Candidate | [
"NewCandidate",
"creates",
"a",
"new",
"Candidate"
] | 0a913e2d71a12fd14a028452435cb71ac8d82cb6 | https://github.com/docker/leadership/blob/0a913e2d71a12fd14a028452435cb71ac8d82cb6/candidate.go#L31-L42 |
9,915 | docker/leadership | candidate.go | RunForElection | func (c *Candidate) RunForElection() (<-chan bool, <-chan error) {
c.electedCh = make(chan bool)
c.errCh = make(chan error)
go c.campaign()
return c.electedCh, c.errCh
} | go | func (c *Candidate) RunForElection() (<-chan bool, <-chan error) {
c.electedCh = make(chan bool)
c.errCh = make(chan error)
go c.campaign()
return c.electedCh, c.errCh
} | [
"func",
"(",
"c",
"*",
"Candidate",
")",
"RunForElection",
"(",
")",
"(",
"<-",
"chan",
"bool",
",",
"<-",
"chan",
"error",
")",
"{",
"c",
".",
"electedCh",
"=",
"make",
"(",
"chan",
"bool",
")",
"\n",
"c",
".",
"errCh",
"=",
"make",
"(",
"chan",
"error",
")",
"\n\n",
"go",
"c",
".",
"campaign",
"(",
")",
"\n\n",
"return",
"c",
".",
"electedCh",
",",
"c",
".",
"errCh",
"\n",
"}"
] | // RunForElection starts the leader election algorithm. Updates in status are
// pushed through the ElectedCh channel.
//
// ElectedCh is used to get a channel which delivers signals on
// acquiring or losing leadership. It sends true if we become
// the leader, and false if we lose it. | [
"RunForElection",
"starts",
"the",
"leader",
"election",
"algorithm",
".",
"Updates",
"in",
"status",
"are",
"pushed",
"through",
"the",
"ElectedCh",
"channel",
".",
"ElectedCh",
"is",
"used",
"to",
"get",
"a",
"channel",
"which",
"delivers",
"signals",
"on",
"acquiring",
"or",
"losing",
"leadership",
".",
"It",
"sends",
"true",
"if",
"we",
"become",
"the",
"leader",
"and",
"false",
"if",
"we",
"lose",
"it",
"."
] | 0a913e2d71a12fd14a028452435cb71ac8d82cb6 | https://github.com/docker/leadership/blob/0a913e2d71a12fd14a028452435cb71ac8d82cb6/candidate.go#L55-L62 |
9,916 | docker/leadership | candidate.go | Resign | func (c *Candidate) Resign() {
c.lock.Lock()
defer c.lock.Unlock()
if c.leader {
c.resignCh <- true
}
} | go | func (c *Candidate) Resign() {
c.lock.Lock()
defer c.lock.Unlock()
if c.leader {
c.resignCh <- true
}
} | [
"func",
"(",
"c",
"*",
"Candidate",
")",
"Resign",
"(",
")",
"{",
"c",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"c",
".",
"leader",
"{",
"c",
".",
"resignCh",
"<-",
"true",
"\n",
"}",
"\n",
"}"
] | // Resign forces the candidate to step-down and try again.
// If the candidate is not a leader, it doesn't have any effect.
// Candidate will retry immediately to acquire the leadership. If no-one else
// took it, then the Candidate will end up being a leader again. | [
"Resign",
"forces",
"the",
"candidate",
"to",
"step",
"-",
"down",
"and",
"try",
"again",
".",
"If",
"the",
"candidate",
"is",
"not",
"a",
"leader",
"it",
"doesn",
"t",
"have",
"any",
"effect",
".",
"Candidate",
"will",
"retry",
"immediately",
"to",
"acquire",
"the",
"leadership",
".",
"If",
"no",
"-",
"one",
"else",
"took",
"it",
"then",
"the",
"Candidate",
"will",
"end",
"up",
"being",
"a",
"leader",
"again",
"."
] | 0a913e2d71a12fd14a028452435cb71ac8d82cb6 | https://github.com/docker/leadership/blob/0a913e2d71a12fd14a028452435cb71ac8d82cb6/candidate.go#L73-L80 |
9,917 | docker/leadership | follower.go | NewFollower | func NewFollower(client store.Store, key string) *Follower {
return &Follower{
client: client,
key: key,
stopCh: make(chan struct{}),
}
} | go | func NewFollower(client store.Store, key string) *Follower {
return &Follower{
client: client,
key: key,
stopCh: make(chan struct{}),
}
} | [
"func",
"NewFollower",
"(",
"client",
"store",
".",
"Store",
",",
"key",
"string",
")",
"*",
"Follower",
"{",
"return",
"&",
"Follower",
"{",
"client",
":",
"client",
",",
"key",
":",
"key",
",",
"stopCh",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"}"
] | // NewFollower creates a new follower. | [
"NewFollower",
"creates",
"a",
"new",
"follower",
"."
] | 0a913e2d71a12fd14a028452435cb71ac8d82cb6 | https://github.com/docker/leadership/blob/0a913e2d71a12fd14a028452435cb71ac8d82cb6/follower.go#L22-L28 |
9,918 | docker/leadership | follower.go | FollowElection | func (f *Follower) FollowElection() (<-chan string, <-chan error) {
f.leaderCh = make(chan string)
f.errCh = make(chan error)
go f.follow()
return f.leaderCh, f.errCh
} | go | func (f *Follower) FollowElection() (<-chan string, <-chan error) {
f.leaderCh = make(chan string)
f.errCh = make(chan error)
go f.follow()
return f.leaderCh, f.errCh
} | [
"func",
"(",
"f",
"*",
"Follower",
")",
"FollowElection",
"(",
")",
"(",
"<-",
"chan",
"string",
",",
"<-",
"chan",
"error",
")",
"{",
"f",
".",
"leaderCh",
"=",
"make",
"(",
"chan",
"string",
")",
"\n",
"f",
".",
"errCh",
"=",
"make",
"(",
"chan",
"error",
")",
"\n\n",
"go",
"f",
".",
"follow",
"(",
")",
"\n\n",
"return",
"f",
".",
"leaderCh",
",",
"f",
".",
"errCh",
"\n",
"}"
] | // FollowElection starts monitoring the election. | [
"FollowElection",
"starts",
"monitoring",
"the",
"election",
"."
] | 0a913e2d71a12fd14a028452435cb71ac8d82cb6 | https://github.com/docker/leadership/blob/0a913e2d71a12fd14a028452435cb71ac8d82cb6/follower.go#L36-L43 |
9,919 | vrecan/death | death.go | NewDeath | func NewDeath(signals ...os.Signal) (death *Death) {
death = &Death{timeout: 10 * time.Second,
sigChannel: make(chan os.Signal, 1),
callChannel: make(chan struct{}, 1),
wg: &sync.WaitGroup{},
log: DefaultLogger()}
signal.Notify(death.sigChannel, signals...)
death.wg.Add(1)
go death.listenForSignal()
return death
} | go | func NewDeath(signals ...os.Signal) (death *Death) {
death = &Death{timeout: 10 * time.Second,
sigChannel: make(chan os.Signal, 1),
callChannel: make(chan struct{}, 1),
wg: &sync.WaitGroup{},
log: DefaultLogger()}
signal.Notify(death.sigChannel, signals...)
death.wg.Add(1)
go death.listenForSignal()
return death
} | [
"func",
"NewDeath",
"(",
"signals",
"...",
"os",
".",
"Signal",
")",
"(",
"death",
"*",
"Death",
")",
"{",
"death",
"=",
"&",
"Death",
"{",
"timeout",
":",
"10",
"*",
"time",
".",
"Second",
",",
"sigChannel",
":",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
",",
"callChannel",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"1",
")",
",",
"wg",
":",
"&",
"sync",
".",
"WaitGroup",
"{",
"}",
",",
"log",
":",
"DefaultLogger",
"(",
")",
"}",
"\n",
"signal",
".",
"Notify",
"(",
"death",
".",
"sigChannel",
",",
"signals",
"...",
")",
"\n",
"death",
".",
"wg",
".",
"Add",
"(",
"1",
")",
"\n",
"go",
"death",
".",
"listenForSignal",
"(",
")",
"\n",
"return",
"death",
"\n",
"}"
] | // NewDeath Create Death with the signals you want to die from. | [
"NewDeath",
"Create",
"Death",
"with",
"the",
"signals",
"you",
"want",
"to",
"die",
"from",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L36-L46 |
9,920 | vrecan/death | death.go | SetTimeout | func (d *Death) SetTimeout(t time.Duration) *Death {
d.timeout = t
return d
} | go | func (d *Death) SetTimeout(t time.Duration) *Death {
d.timeout = t
return d
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"SetTimeout",
"(",
"t",
"time",
".",
"Duration",
")",
"*",
"Death",
"{",
"d",
".",
"timeout",
"=",
"t",
"\n",
"return",
"d",
"\n",
"}"
] | // SetTimeout Overrides the time death is willing to wait for a objects to be closed. | [
"SetTimeout",
"Overrides",
"the",
"time",
"death",
"is",
"willing",
"to",
"wait",
"for",
"a",
"objects",
"to",
"be",
"closed",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L49-L52 |
9,921 | vrecan/death | death.go | WaitForDeath | func (d *Death) WaitForDeath(closable ...io.Closer) (err error) {
d.wg.Wait()
d.log.Info("Shutdown started...")
count := len(closable)
d.log.Debug("Closing ", count, " objects")
if count > 0 {
return d.closeInMass(closable...)
}
return nil
} | go | func (d *Death) WaitForDeath(closable ...io.Closer) (err error) {
d.wg.Wait()
d.log.Info("Shutdown started...")
count := len(closable)
d.log.Debug("Closing ", count, " objects")
if count > 0 {
return d.closeInMass(closable...)
}
return nil
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"WaitForDeath",
"(",
"closable",
"...",
"io",
".",
"Closer",
")",
"(",
"err",
"error",
")",
"{",
"d",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"d",
".",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"count",
":=",
"len",
"(",
"closable",
")",
"\n",
"d",
".",
"log",
".",
"Debug",
"(",
"\"",
"\"",
",",
"count",
",",
"\"",
"\"",
")",
"\n",
"if",
"count",
">",
"0",
"{",
"return",
"d",
".",
"closeInMass",
"(",
"closable",
"...",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // WaitForDeath wait for signal and then kill all items that need to die. If they fail to
// die when instructed we return an error | [
"WaitForDeath",
"wait",
"for",
"signal",
"and",
"then",
"kill",
"all",
"items",
"that",
"need",
"to",
"die",
".",
"If",
"they",
"fail",
"to",
"die",
"when",
"instructed",
"we",
"return",
"an",
"error"
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L62-L71 |
9,922 | vrecan/death | death.go | WaitForDeathWithFunc | func (d *Death) WaitForDeathWithFunc(f func()) {
d.wg.Wait()
d.log.Info("Shutdown started...")
f()
} | go | func (d *Death) WaitForDeathWithFunc(f func()) {
d.wg.Wait()
d.log.Info("Shutdown started...")
f()
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"WaitForDeathWithFunc",
"(",
"f",
"func",
"(",
")",
")",
"{",
"d",
".",
"wg",
".",
"Wait",
"(",
")",
"\n",
"d",
".",
"log",
".",
"Info",
"(",
"\"",
"\"",
")",
"\n",
"f",
"(",
")",
"\n",
"}"
] | // WaitForDeathWithFunc allows you to have a single function get called when it's time to
// kill your application. | [
"WaitForDeathWithFunc",
"allows",
"you",
"to",
"have",
"a",
"single",
"function",
"get",
"called",
"when",
"it",
"s",
"time",
"to",
"kill",
"your",
"application",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L75-L79 |
9,923 | vrecan/death | death.go | getPkgPath | func getPkgPath(c io.Closer) (name string, pkgPath string) {
t := reflect.TypeOf(c)
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t.Name(), t.PkgPath()
} | go | func getPkgPath(c io.Closer) (name string, pkgPath string) {
t := reflect.TypeOf(c)
if t.Kind() == reflect.Ptr {
t = t.Elem()
}
return t.Name(), t.PkgPath()
} | [
"func",
"getPkgPath",
"(",
"c",
"io",
".",
"Closer",
")",
"(",
"name",
"string",
",",
"pkgPath",
"string",
")",
"{",
"t",
":=",
"reflect",
".",
"TypeOf",
"(",
"c",
")",
"\n",
"if",
"t",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"t",
"=",
"t",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n",
"return",
"t",
".",
"Name",
"(",
")",
",",
"t",
".",
"PkgPath",
"(",
")",
"\n",
"}"
] | // getPkgPath for an io closer. | [
"getPkgPath",
"for",
"an",
"io",
"closer",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L82-L88 |
9,924 | vrecan/death | death.go | closeInMass | func (d *Death) closeInMass(closable ...io.Closer) (err error) {
count := len(closable)
sentToClose := make(map[int]closer)
//call close async
doneClosers := make(chan closer, count)
for i, c := range closable {
name, pkgPath := getPkgPath(c)
closer := closer{Index: i, C: c, Name: name, PKGPath: pkgPath}
go d.closeObjects(closer, doneClosers)
sentToClose[i] = closer
}
// wait on channel for notifications.
timer := time.NewTimer(d.timeout)
failedClosers := []closer{}
for {
select {
case <-timer.C:
s := "failed to close: "
pkgs := []string{}
for _, c := range sentToClose {
pkgs = append(pkgs, fmt.Sprintf("%s/%s", c.PKGPath, c.Name))
d.log.Error("Failed to close: ", c.PKGPath, "/", c.Name)
}
return fmt.Errorf("%s", fmt.Sprintf("%s %s", s, strings.Join(pkgs, ", ")))
case closer := <-doneClosers:
delete(sentToClose, closer.Index)
count--
if closer.Err != nil {
failedClosers = append(failedClosers, closer)
}
d.log.Debug(count, " object(s) left")
if count != 0 || len(sentToClose) != 0 {
continue
}
if len(failedClosers) != 0 {
errString := generateErrString(failedClosers)
return fmt.Errorf("errors from closers: %s", errString)
}
return nil
}
}
} | go | func (d *Death) closeInMass(closable ...io.Closer) (err error) {
count := len(closable)
sentToClose := make(map[int]closer)
//call close async
doneClosers := make(chan closer, count)
for i, c := range closable {
name, pkgPath := getPkgPath(c)
closer := closer{Index: i, C: c, Name: name, PKGPath: pkgPath}
go d.closeObjects(closer, doneClosers)
sentToClose[i] = closer
}
// wait on channel for notifications.
timer := time.NewTimer(d.timeout)
failedClosers := []closer{}
for {
select {
case <-timer.C:
s := "failed to close: "
pkgs := []string{}
for _, c := range sentToClose {
pkgs = append(pkgs, fmt.Sprintf("%s/%s", c.PKGPath, c.Name))
d.log.Error("Failed to close: ", c.PKGPath, "/", c.Name)
}
return fmt.Errorf("%s", fmt.Sprintf("%s %s", s, strings.Join(pkgs, ", ")))
case closer := <-doneClosers:
delete(sentToClose, closer.Index)
count--
if closer.Err != nil {
failedClosers = append(failedClosers, closer)
}
d.log.Debug(count, " object(s) left")
if count != 0 || len(sentToClose) != 0 {
continue
}
if len(failedClosers) != 0 {
errString := generateErrString(failedClosers)
return fmt.Errorf("errors from closers: %s", errString)
}
return nil
}
}
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"closeInMass",
"(",
"closable",
"...",
"io",
".",
"Closer",
")",
"(",
"err",
"error",
")",
"{",
"count",
":=",
"len",
"(",
"closable",
")",
"\n",
"sentToClose",
":=",
"make",
"(",
"map",
"[",
"int",
"]",
"closer",
")",
"\n",
"//call close async",
"doneClosers",
":=",
"make",
"(",
"chan",
"closer",
",",
"count",
")",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"closable",
"{",
"name",
",",
"pkgPath",
":=",
"getPkgPath",
"(",
"c",
")",
"\n",
"closer",
":=",
"closer",
"{",
"Index",
":",
"i",
",",
"C",
":",
"c",
",",
"Name",
":",
"name",
",",
"PKGPath",
":",
"pkgPath",
"}",
"\n",
"go",
"d",
".",
"closeObjects",
"(",
"closer",
",",
"doneClosers",
")",
"\n",
"sentToClose",
"[",
"i",
"]",
"=",
"closer",
"\n",
"}",
"\n\n",
"// wait on channel for notifications.",
"timer",
":=",
"time",
".",
"NewTimer",
"(",
"d",
".",
"timeout",
")",
"\n",
"failedClosers",
":=",
"[",
"]",
"closer",
"{",
"}",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"timer",
".",
"C",
":",
"s",
":=",
"\"",
"\"",
"\n",
"pkgs",
":=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"sentToClose",
"{",
"pkgs",
"=",
"append",
"(",
"pkgs",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"PKGPath",
",",
"c",
".",
"Name",
")",
")",
"\n",
"d",
".",
"log",
".",
"Error",
"(",
"\"",
"\"",
",",
"c",
".",
"PKGPath",
",",
"\"",
"\"",
",",
"c",
".",
"Name",
")",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
",",
"strings",
".",
"Join",
"(",
"pkgs",
",",
"\"",
"\"",
")",
")",
")",
"\n",
"case",
"closer",
":=",
"<-",
"doneClosers",
":",
"delete",
"(",
"sentToClose",
",",
"closer",
".",
"Index",
")",
"\n",
"count",
"--",
"\n",
"if",
"closer",
".",
"Err",
"!=",
"nil",
"{",
"failedClosers",
"=",
"append",
"(",
"failedClosers",
",",
"closer",
")",
"\n",
"}",
"\n\n",
"d",
".",
"log",
".",
"Debug",
"(",
"count",
",",
"\"",
"\"",
")",
"\n",
"if",
"count",
"!=",
"0",
"||",
"len",
"(",
"sentToClose",
")",
"!=",
"0",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"failedClosers",
")",
"!=",
"0",
"{",
"errString",
":=",
"generateErrString",
"(",
"failedClosers",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"errString",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // closeInMass Close all the objects at once and wait for them to finish with a channel. Return an
// error if you fail to close all the objects | [
"closeInMass",
"Close",
"all",
"the",
"objects",
"at",
"once",
"and",
"wait",
"for",
"them",
"to",
"finish",
"with",
"a",
"channel",
".",
"Return",
"an",
"error",
"if",
"you",
"fail",
"to",
"close",
"all",
"the",
"objects"
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L92-L138 |
9,925 | vrecan/death | death.go | closeObjects | func (d *Death) closeObjects(closer closer, done chan<- closer) {
err := closer.C.Close()
if err != nil {
d.log.Error(err)
closer.Err = err
}
done <- closer
} | go | func (d *Death) closeObjects(closer closer, done chan<- closer) {
err := closer.C.Close()
if err != nil {
d.log.Error(err)
closer.Err = err
}
done <- closer
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"closeObjects",
"(",
"closer",
"closer",
",",
"done",
"chan",
"<-",
"closer",
")",
"{",
"err",
":=",
"closer",
".",
"C",
".",
"Close",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"d",
".",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"closer",
".",
"Err",
"=",
"err",
"\n",
"}",
"\n",
"done",
"<-",
"closer",
"\n",
"}"
] | // closeObjects and return a bool when finished on a channel. | [
"closeObjects",
"and",
"return",
"a",
"bool",
"when",
"finished",
"on",
"a",
"channel",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L141-L148 |
9,926 | vrecan/death | death.go | listenForSignal | func (d *Death) listenForSignal() {
defer d.wg.Done()
for {
select {
case <-d.sigChannel:
return
case <-d.callChannel:
return
}
}
} | go | func (d *Death) listenForSignal() {
defer d.wg.Done()
for {
select {
case <-d.sigChannel:
return
case <-d.callChannel:
return
}
}
} | [
"func",
"(",
"d",
"*",
"Death",
")",
"listenForSignal",
"(",
")",
"{",
"defer",
"d",
".",
"wg",
".",
"Done",
"(",
")",
"\n",
"for",
"{",
"select",
"{",
"case",
"<-",
"d",
".",
"sigChannel",
":",
"return",
"\n",
"case",
"<-",
"d",
".",
"callChannel",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // ListenForSignal Manage death of application by signal. | [
"ListenForSignal",
"Manage",
"death",
"of",
"application",
"by",
"signal",
"."
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L159-L169 |
9,927 | vrecan/death | death.go | generateErrString | func generateErrString(failedClosers []closer) (errString string) {
for i, fc := range failedClosers {
if i == 0 {
errString = fmt.Sprintf("%s/%s: %s", fc.PKGPath, fc.Name, fc.Err)
continue
}
errString = fmt.Sprintf("%s, %s/%s: %s", errString, fc.PKGPath, fc.Name, fc.Err)
}
return errString
} | go | func generateErrString(failedClosers []closer) (errString string) {
for i, fc := range failedClosers {
if i == 0 {
errString = fmt.Sprintf("%s/%s: %s", fc.PKGPath, fc.Name, fc.Err)
continue
}
errString = fmt.Sprintf("%s, %s/%s: %s", errString, fc.PKGPath, fc.Name, fc.Err)
}
return errString
} | [
"func",
"generateErrString",
"(",
"failedClosers",
"[",
"]",
"closer",
")",
"(",
"errString",
"string",
")",
"{",
"for",
"i",
",",
"fc",
":=",
"range",
"failedClosers",
"{",
"if",
"i",
"==",
"0",
"{",
"errString",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fc",
".",
"PKGPath",
",",
"fc",
".",
"Name",
",",
"fc",
".",
"Err",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"errString",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"errString",
",",
"fc",
".",
"PKGPath",
",",
"fc",
".",
"Name",
",",
"fc",
".",
"Err",
")",
"\n",
"}",
"\n\n",
"return",
"errString",
"\n",
"}"
] | // generateErrString generates a string containing a list of tuples of pkgname to error message | [
"generateErrString",
"generates",
"a",
"string",
"containing",
"a",
"list",
"of",
"tuples",
"of",
"pkgname",
"to",
"error",
"message"
] | eb9a1d773e1be97f42a579c803d5b6bf5ba96768 | https://github.com/vrecan/death/blob/eb9a1d773e1be97f42a579c803d5b6bf5ba96768/death.go#L172-L182 |
9,928 | djherbis/times | ctime_windows.go | Stat | func Stat(name string) (Timespec, error) {
ts, err := platformSpecficStat(name)
if err == nil {
return ts, err
}
return stat(name, os.Stat)
} | go | func Stat(name string) (Timespec, error) {
ts, err := platformSpecficStat(name)
if err == nil {
return ts, err
}
return stat(name, os.Stat)
} | [
"func",
"Stat",
"(",
"name",
"string",
")",
"(",
"Timespec",
",",
"error",
")",
"{",
"ts",
",",
"err",
":=",
"platformSpecficStat",
"(",
"name",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"ts",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stat",
"(",
"name",
",",
"os",
".",
"Stat",
")",
"\n",
"}"
] | // Stat returns the Timespec for the given filename. | [
"Stat",
"returns",
"the",
"Timespec",
"for",
"the",
"given",
"filename",
"."
] | 847c5208d8924cea0acea3376ff62aede93afe39 | https://github.com/djherbis/times/blob/847c5208d8924cea0acea3376ff62aede93afe39/ctime_windows.go#L11-L18 |
9,929 | djherbis/times | ctime_windows.go | Lstat | func Lstat(name string) (Timespec, error) {
ts, err := platformSpecficLstat(name)
if err == nil {
return ts, err
}
return stat(name, os.Lstat)
} | go | func Lstat(name string) (Timespec, error) {
ts, err := platformSpecficLstat(name)
if err == nil {
return ts, err
}
return stat(name, os.Lstat)
} | [
"func",
"Lstat",
"(",
"name",
"string",
")",
"(",
"Timespec",
",",
"error",
")",
"{",
"ts",
",",
"err",
":=",
"platformSpecficLstat",
"(",
"name",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"ts",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"stat",
"(",
"name",
",",
"os",
".",
"Lstat",
")",
"\n",
"}"
] | // Lstat returns the Timespec for the given filename, and does not follow Symlinks. | [
"Lstat",
"returns",
"the",
"Timespec",
"for",
"the",
"given",
"filename",
"and",
"does",
"not",
"follow",
"Symlinks",
"."
] | 847c5208d8924cea0acea3376ff62aede93afe39 | https://github.com/djherbis/times/blob/847c5208d8924cea0acea3376ff62aede93afe39/ctime_windows.go#L21-L28 |
9,930 | djherbis/times | ctime_windows.go | StatFile | func StatFile(file *os.File) (Timespec, error) {
return statFile(syscall.Handle(file.Fd()))
} | go | func StatFile(file *os.File) (Timespec, error) {
return statFile(syscall.Handle(file.Fd()))
} | [
"func",
"StatFile",
"(",
"file",
"*",
"os",
".",
"File",
")",
"(",
"Timespec",
",",
"error",
")",
"{",
"return",
"statFile",
"(",
"syscall",
".",
"Handle",
"(",
"file",
".",
"Fd",
"(",
")",
")",
")",
"\n",
"}"
] | // StatFile finds a Windows Timespec with ChangeTime. | [
"StatFile",
"finds",
"a",
"Windows",
"Timespec",
"with",
"ChangeTime",
"."
] | 847c5208d8924cea0acea3376ff62aede93afe39 | https://github.com/djherbis/times/blob/847c5208d8924cea0acea3376ff62aede93afe39/ctime_windows.go#L38-L40 |
9,931 | oskca/gopherjs-vue | component.go | NewComponent | func NewComponent(
vmCreator func() (structPtr interface{}),
templateStr string,
replaceMountPoint ...bool,
) *Component {
// args
idx := len(creatorPool)
creatorPool = append(creatorPool, new(pool))
creatorPool[idx].creator = vmCreator
vmfn := func() interface{} {
p := creatorPool[idx]
if p.counter%3 == 0 {
p.structPtr = p.creator()
}
p.counter += 1
return p.structPtr
}
// opts
opt := NewOption()
opt.Data = vmfn
opt.Template = templateStr
opt.OnLifeCycleEvent(EvtBeforeCreate, func(vm *ViewModel) {
vm.Options.Set("methods", js.MakeWrapper(vmfn()))
vMap[vmfn()] = vm
})
return opt.NewComponent()
} | go | func NewComponent(
vmCreator func() (structPtr interface{}),
templateStr string,
replaceMountPoint ...bool,
) *Component {
// args
idx := len(creatorPool)
creatorPool = append(creatorPool, new(pool))
creatorPool[idx].creator = vmCreator
vmfn := func() interface{} {
p := creatorPool[idx]
if p.counter%3 == 0 {
p.structPtr = p.creator()
}
p.counter += 1
return p.structPtr
}
// opts
opt := NewOption()
opt.Data = vmfn
opt.Template = templateStr
opt.OnLifeCycleEvent(EvtBeforeCreate, func(vm *ViewModel) {
vm.Options.Set("methods", js.MakeWrapper(vmfn()))
vMap[vmfn()] = vm
})
return opt.NewComponent()
} | [
"func",
"NewComponent",
"(",
"vmCreator",
"func",
"(",
")",
"(",
"structPtr",
"interface",
"{",
"}",
")",
",",
"templateStr",
"string",
",",
"replaceMountPoint",
"...",
"bool",
",",
")",
"*",
"Component",
"{",
"// args",
"idx",
":=",
"len",
"(",
"creatorPool",
")",
"\n",
"creatorPool",
"=",
"append",
"(",
"creatorPool",
",",
"new",
"(",
"pool",
")",
")",
"\n",
"creatorPool",
"[",
"idx",
"]",
".",
"creator",
"=",
"vmCreator",
"\n",
"vmfn",
":=",
"func",
"(",
")",
"interface",
"{",
"}",
"{",
"p",
":=",
"creatorPool",
"[",
"idx",
"]",
"\n",
"if",
"p",
".",
"counter",
"%",
"3",
"==",
"0",
"{",
"p",
".",
"structPtr",
"=",
"p",
".",
"creator",
"(",
")",
"\n",
"}",
"\n",
"p",
".",
"counter",
"+=",
"1",
"\n",
"return",
"p",
".",
"structPtr",
"\n",
"}",
"\n",
"// opts",
"opt",
":=",
"NewOption",
"(",
")",
"\n",
"opt",
".",
"Data",
"=",
"vmfn",
"\n",
"opt",
".",
"Template",
"=",
"templateStr",
"\n",
"opt",
".",
"OnLifeCycleEvent",
"(",
"EvtBeforeCreate",
",",
"func",
"(",
"vm",
"*",
"ViewModel",
")",
"{",
"vm",
".",
"Options",
".",
"Set",
"(",
"\"",
"\"",
",",
"js",
".",
"MakeWrapper",
"(",
"vmfn",
"(",
")",
")",
")",
"\n",
"vMap",
"[",
"vmfn",
"(",
")",
"]",
"=",
"vm",
"\n",
"}",
")",
"\n",
"return",
"opt",
".",
"NewComponent",
"(",
")",
"\n",
"}"
] | // NewComponent creates and registers a named global Component
//
// vmCreator should return a gopherjs struct pointer. see New for more details | [
"NewComponent",
"creates",
"and",
"registers",
"a",
"named",
"global",
"Component",
"vmCreator",
"should",
"return",
"a",
"gopherjs",
"struct",
"pointer",
".",
"see",
"New",
"for",
"more",
"details"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/component.go#L49-L75 |
9,932 | oskca/gopherjs-vue | vue.go | Push | func Push(obj *js.Object, any interface{}) (idx int) {
return obj.Call("push", any).Int()
} | go | func Push(obj *js.Object, any interface{}) (idx int) {
return obj.Call("push", any).Int()
} | [
"func",
"Push",
"(",
"obj",
"*",
"js",
".",
"Object",
",",
"any",
"interface",
"{",
"}",
")",
"(",
"idx",
"int",
")",
"{",
"return",
"obj",
".",
"Call",
"(",
"\"",
"\"",
",",
"any",
")",
".",
"Int",
"(",
")",
"\n",
"}"
] | // Add in the bottom of the array | [
"Add",
"in",
"the",
"bottom",
"of",
"the",
"array"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/vue.go#L15-L17 |
9,933 | oskca/gopherjs-vue | mapping.go | FromJS | func (v *ViewModel) FromJS(obj *js.Object) *ViewModel {
for _, key := range js.Keys(obj) {
// skip internal or unexported field
if strings.HasPrefix(key, "$") || strings.HasPrefix(key, "_") {
continue
}
v.Object.Set(key, obj.Get(key))
}
return v
} | go | func (v *ViewModel) FromJS(obj *js.Object) *ViewModel {
for _, key := range js.Keys(obj) {
// skip internal or unexported field
if strings.HasPrefix(key, "$") || strings.HasPrefix(key, "_") {
continue
}
v.Object.Set(key, obj.Get(key))
}
return v
} | [
"func",
"(",
"v",
"*",
"ViewModel",
")",
"FromJS",
"(",
"obj",
"*",
"js",
".",
"Object",
")",
"*",
"ViewModel",
"{",
"for",
"_",
",",
"key",
":=",
"range",
"js",
".",
"Keys",
"(",
"obj",
")",
"{",
"// skip internal or unexported field",
"if",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"HasPrefix",
"(",
"key",
",",
"\"",
"\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"v",
".",
"Object",
".",
"Set",
"(",
"key",
",",
"obj",
".",
"Get",
"(",
"key",
")",
")",
"\n",
"}",
"\n",
"return",
"v",
"\n",
"}"
] | // FromJS set the corresponding VueJS data model field from obj
// new data model field will be created when not exist | [
"FromJS",
"set",
"the",
"corresponding",
"VueJS",
"data",
"model",
"field",
"from",
"obj",
"new",
"data",
"model",
"field",
"will",
"be",
"created",
"when",
"not",
"exist"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/mapping.go#L12-L21 |
9,934 | oskca/gopherjs-vue | option.go | prepare | func (c *Option) prepare() (opts *js.Object) {
if len(c.coms) > 0 {
c.Set("components", c.coms)
}
if len(c.props) > 0 {
c.Set("props", c.props)
}
if len(c.mixins) > 0 {
c.Set("mixins", c.mixins)
}
return c.Object
} | go | func (c *Option) prepare() (opts *js.Object) {
if len(c.coms) > 0 {
c.Set("components", c.coms)
}
if len(c.props) > 0 {
c.Set("props", c.props)
}
if len(c.mixins) > 0 {
c.Set("mixins", c.mixins)
}
return c.Object
} | [
"func",
"(",
"c",
"*",
"Option",
")",
"prepare",
"(",
")",
"(",
"opts",
"*",
"js",
".",
"Object",
")",
"{",
"if",
"len",
"(",
"c",
".",
"coms",
")",
">",
"0",
"{",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"coms",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"c",
".",
"props",
")",
">",
"0",
"{",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"props",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"c",
".",
"mixins",
")",
">",
"0",
"{",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"c",
".",
"mixins",
")",
"\n",
"}",
"\n",
"return",
"c",
".",
"Object",
"\n",
"}"
] | // prepare set the proper options into js.Object | [
"prepare",
"set",
"the",
"proper",
"options",
"into",
"js",
".",
"Object"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/option.go#L181-L192 |
9,935 | oskca/gopherjs-vue | option.go | AddMethod | func (o *Option) AddMethod(name string, fn func(vm *ViewModel, args []*js.Object)) *Option {
return o.addMixin("methods", js.M{
name: js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
fn(vm, arguments)
return nil
}),
})
} | go | func (o *Option) AddMethod(name string, fn func(vm *ViewModel, args []*js.Object)) *Option {
return o.addMixin("methods", js.M{
name: js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
fn(vm, arguments)
return nil
}),
})
} | [
"func",
"(",
"o",
"*",
"Option",
")",
"AddMethod",
"(",
"name",
"string",
",",
"fn",
"func",
"(",
"vm",
"*",
"ViewModel",
",",
"args",
"[",
"]",
"*",
"js",
".",
"Object",
")",
")",
"*",
"Option",
"{",
"return",
"o",
".",
"addMixin",
"(",
"\"",
"\"",
",",
"js",
".",
"M",
"{",
"name",
":",
"js",
".",
"MakeFunc",
"(",
"func",
"(",
"this",
"*",
"js",
".",
"Object",
",",
"arguments",
"[",
"]",
"*",
"js",
".",
"Object",
")",
"interface",
"{",
"}",
"{",
"vm",
":=",
"newViewModel",
"(",
"this",
")",
"\n",
"fn",
"(",
"vm",
",",
"arguments",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
",",
"}",
")",
"\n",
"}"
] | // AddMethod adds new method `name` to VueJS intance or component
// using mixins thus will never conflict with Option.SetDataWithMethods | [
"AddMethod",
"adds",
"new",
"method",
"name",
"to",
"VueJS",
"intance",
"or",
"component",
"using",
"mixins",
"thus",
"will",
"never",
"conflict",
"with",
"Option",
".",
"SetDataWithMethods"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/option.go#L207-L215 |
9,936 | oskca/gopherjs-vue | option.go | AddComputed | func (o *Option) AddComputed(name string, getter func(vm *ViewModel) interface{}, setter ...func(vm *ViewModel, val *js.Object)) {
conf := make(map[string]js.M)
conf[name] = make(js.M)
fnGetter := js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
return getter(vm)
})
conf[name]["get"] = fnGetter
if len(setter) > 0 {
fnSetter := js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
setter[0](vm, arguments[0])
return nil
})
conf[name]["set"] = fnSetter
}
// using mixin here
o.addMixin("computed", conf)
} | go | func (o *Option) AddComputed(name string, getter func(vm *ViewModel) interface{}, setter ...func(vm *ViewModel, val *js.Object)) {
conf := make(map[string]js.M)
conf[name] = make(js.M)
fnGetter := js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
return getter(vm)
})
conf[name]["get"] = fnGetter
if len(setter) > 0 {
fnSetter := js.MakeFunc(func(this *js.Object, arguments []*js.Object) interface{} {
vm := newViewModel(this)
setter[0](vm, arguments[0])
return nil
})
conf[name]["set"] = fnSetter
}
// using mixin here
o.addMixin("computed", conf)
} | [
"func",
"(",
"o",
"*",
"Option",
")",
"AddComputed",
"(",
"name",
"string",
",",
"getter",
"func",
"(",
"vm",
"*",
"ViewModel",
")",
"interface",
"{",
"}",
",",
"setter",
"...",
"func",
"(",
"vm",
"*",
"ViewModel",
",",
"val",
"*",
"js",
".",
"Object",
")",
")",
"{",
"conf",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"js",
".",
"M",
")",
"\n",
"conf",
"[",
"name",
"]",
"=",
"make",
"(",
"js",
".",
"M",
")",
"\n",
"fnGetter",
":=",
"js",
".",
"MakeFunc",
"(",
"func",
"(",
"this",
"*",
"js",
".",
"Object",
",",
"arguments",
"[",
"]",
"*",
"js",
".",
"Object",
")",
"interface",
"{",
"}",
"{",
"vm",
":=",
"newViewModel",
"(",
"this",
")",
"\n",
"return",
"getter",
"(",
"vm",
")",
"\n",
"}",
")",
"\n",
"conf",
"[",
"name",
"]",
"[",
"\"",
"\"",
"]",
"=",
"fnGetter",
"\n",
"if",
"len",
"(",
"setter",
")",
">",
"0",
"{",
"fnSetter",
":=",
"js",
".",
"MakeFunc",
"(",
"func",
"(",
"this",
"*",
"js",
".",
"Object",
",",
"arguments",
"[",
"]",
"*",
"js",
".",
"Object",
")",
"interface",
"{",
"}",
"{",
"vm",
":=",
"newViewModel",
"(",
"this",
")",
"\n",
"setter",
"[",
"0",
"]",
"(",
"vm",
",",
"arguments",
"[",
"0",
"]",
")",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"conf",
"[",
"name",
"]",
"[",
"\"",
"\"",
"]",
"=",
"fnSetter",
"\n",
"}",
"\n",
"// using mixin here",
"o",
".",
"addMixin",
"(",
"\"",
"\"",
",",
"conf",
")",
"\n",
"}"
] | // AddComputed set computed data | [
"AddComputed",
"set",
"computed",
"data"
] | ab40c9e57345d35375c820c8e885d28ed70f165e | https://github.com/oskca/gopherjs-vue/blob/ab40c9e57345d35375c820c8e885d28ed70f165e/option.go#L234-L252 |
9,937 | 256dpi/gomqtt | transport/websocket_conn.go | NewWebSocketConn | func NewWebSocketConn(conn *websocket.Conn, maxWriteDelay time.Duration) *WebSocketConn {
return &WebSocketConn{
BaseConn: NewBaseConn(&wsStream{conn: conn}, maxWriteDelay),
conn: conn,
}
} | go | func NewWebSocketConn(conn *websocket.Conn, maxWriteDelay time.Duration) *WebSocketConn {
return &WebSocketConn{
BaseConn: NewBaseConn(&wsStream{conn: conn}, maxWriteDelay),
conn: conn,
}
} | [
"func",
"NewWebSocketConn",
"(",
"conn",
"*",
"websocket",
".",
"Conn",
",",
"maxWriteDelay",
"time",
".",
"Duration",
")",
"*",
"WebSocketConn",
"{",
"return",
"&",
"WebSocketConn",
"{",
"BaseConn",
":",
"NewBaseConn",
"(",
"&",
"wsStream",
"{",
"conn",
":",
"conn",
"}",
",",
"maxWriteDelay",
")",
",",
"conn",
":",
"conn",
",",
"}",
"\n",
"}"
] | // NewWebSocketConn returns a new WebSocketConn. | [
"NewWebSocketConn",
"returns",
"a",
"new",
"WebSocketConn",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/websocket_conn.go#L106-L111 |
9,938 | 256dpi/gomqtt | packet/packet.go | Successful | func (qos QOS) Successful() bool {
return qos == QOSAtMostOnce || qos == QOSAtLeastOnce || qos == QOSExactlyOnce
} | go | func (qos QOS) Successful() bool {
return qos == QOSAtMostOnce || qos == QOSAtLeastOnce || qos == QOSExactlyOnce
} | [
"func",
"(",
"qos",
"QOS",
")",
"Successful",
"(",
")",
"bool",
"{",
"return",
"qos",
"==",
"QOSAtMostOnce",
"||",
"qos",
"==",
"QOSAtLeastOnce",
"||",
"qos",
"==",
"QOSExactlyOnce",
"\n",
"}"
] | // Successful returns if the provided quality of service level represents a
// successful value. | [
"Successful",
"returns",
"if",
"the",
"provided",
"quality",
"of",
"service",
"level",
"represents",
"a",
"successful",
"value",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/packet.go#L27-L29 |
9,939 | 256dpi/gomqtt | packet/packet.go | DetectPacket | func DetectPacket(src []byte) (int, Type) {
// check for minimum size
if len(src) < 2 {
return 0, 0
}
// get type
t := Type(src[0] >> 4)
// get remaining length
rl, n := binary.Uvarint(src[1:])
if n <= 0 {
return 0, 0
}
return 1 + n + int(rl), t
} | go | func DetectPacket(src []byte) (int, Type) {
// check for minimum size
if len(src) < 2 {
return 0, 0
}
// get type
t := Type(src[0] >> 4)
// get remaining length
rl, n := binary.Uvarint(src[1:])
if n <= 0 {
return 0, 0
}
return 1 + n + int(rl), t
} | [
"func",
"DetectPacket",
"(",
"src",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"Type",
")",
"{",
"// check for minimum size",
"if",
"len",
"(",
"src",
")",
"<",
"2",
"{",
"return",
"0",
",",
"0",
"\n",
"}",
"\n\n",
"// get type",
"t",
":=",
"Type",
"(",
"src",
"[",
"0",
"]",
">>",
"4",
")",
"\n\n",
"// get remaining length",
"rl",
",",
"n",
":=",
"binary",
".",
"Uvarint",
"(",
"src",
"[",
"1",
":",
"]",
")",
"\n",
"if",
"n",
"<=",
"0",
"{",
"return",
"0",
",",
"0",
"\n",
"}",
"\n\n",
"return",
"1",
"+",
"n",
"+",
"int",
"(",
"rl",
")",
",",
"t",
"\n",
"}"
] | // DetectPacket tries to detect the next packet in a buffer. It returns a length
// greater than zero if the packet has been detected as well as its Type. | [
"DetectPacket",
"tries",
"to",
"detect",
"the",
"next",
"packet",
"in",
"a",
"buffer",
".",
"It",
"returns",
"a",
"length",
"greater",
"than",
"zero",
"if",
"the",
"packet",
"has",
"been",
"detected",
"as",
"well",
"as",
"its",
"Type",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/packet.go#L63-L79 |
9,940 | 256dpi/gomqtt | packet/packet.go | GetID | func GetID(pkt Generic) (ID, bool) {
switch pkt.Type() {
case PUBLISH:
return pkt.(*Publish).ID, true
case PUBACK:
return pkt.(*Puback).ID, true
case PUBREC:
return pkt.(*Pubrec).ID, true
case PUBREL:
return pkt.(*Pubrel).ID, true
case PUBCOMP:
return pkt.(*Pubcomp).ID, true
case SUBSCRIBE:
return pkt.(*Subscribe).ID, true
case SUBACK:
return pkt.(*Suback).ID, true
case UNSUBSCRIBE:
return pkt.(*Unsubscribe).ID, true
case UNSUBACK:
return pkt.(*Unsuback).ID, true
}
return 0, false
} | go | func GetID(pkt Generic) (ID, bool) {
switch pkt.Type() {
case PUBLISH:
return pkt.(*Publish).ID, true
case PUBACK:
return pkt.(*Puback).ID, true
case PUBREC:
return pkt.(*Pubrec).ID, true
case PUBREL:
return pkt.(*Pubrel).ID, true
case PUBCOMP:
return pkt.(*Pubcomp).ID, true
case SUBSCRIBE:
return pkt.(*Subscribe).ID, true
case SUBACK:
return pkt.(*Suback).ID, true
case UNSUBSCRIBE:
return pkt.(*Unsubscribe).ID, true
case UNSUBACK:
return pkt.(*Unsuback).ID, true
}
return 0, false
} | [
"func",
"GetID",
"(",
"pkt",
"Generic",
")",
"(",
"ID",
",",
"bool",
")",
"{",
"switch",
"pkt",
".",
"Type",
"(",
")",
"{",
"case",
"PUBLISH",
":",
"return",
"pkt",
".",
"(",
"*",
"Publish",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"PUBACK",
":",
"return",
"pkt",
".",
"(",
"*",
"Puback",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"PUBREC",
":",
"return",
"pkt",
".",
"(",
"*",
"Pubrec",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"PUBREL",
":",
"return",
"pkt",
".",
"(",
"*",
"Pubrel",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"PUBCOMP",
":",
"return",
"pkt",
".",
"(",
"*",
"Pubcomp",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"SUBSCRIBE",
":",
"return",
"pkt",
".",
"(",
"*",
"Subscribe",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"SUBACK",
":",
"return",
"pkt",
".",
"(",
"*",
"Suback",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"UNSUBSCRIBE",
":",
"return",
"pkt",
".",
"(",
"*",
"Unsubscribe",
")",
".",
"ID",
",",
"true",
"\n",
"case",
"UNSUBACK",
":",
"return",
"pkt",
".",
"(",
"*",
"Unsuback",
")",
".",
"ID",
",",
"true",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"false",
"\n",
"}"
] | // GetID checks the packets type and returns its ID and true, or if it
// does not have a ID, zero and false. | [
"GetID",
"checks",
"the",
"packets",
"type",
"and",
"returns",
"its",
"ID",
"and",
"true",
"or",
"if",
"it",
"does",
"not",
"have",
"a",
"ID",
"zero",
"and",
"false",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/packet.go#L83-L106 |
9,941 | 256dpi/gomqtt | transport/net_conn.go | NewNetConn | func NewNetConn(conn net.Conn, maxWriteDelay time.Duration) *NetConn {
return &NetConn{
BaseConn: NewBaseConn(conn, maxWriteDelay),
conn: conn,
}
} | go | func NewNetConn(conn net.Conn, maxWriteDelay time.Duration) *NetConn {
return &NetConn{
BaseConn: NewBaseConn(conn, maxWriteDelay),
conn: conn,
}
} | [
"func",
"NewNetConn",
"(",
"conn",
"net",
".",
"Conn",
",",
"maxWriteDelay",
"time",
".",
"Duration",
")",
"*",
"NetConn",
"{",
"return",
"&",
"NetConn",
"{",
"BaseConn",
":",
"NewBaseConn",
"(",
"conn",
",",
"maxWriteDelay",
")",
",",
"conn",
":",
"conn",
",",
"}",
"\n",
"}"
] | // NewNetConn returns a new NetConn. | [
"NewNetConn",
"returns",
"a",
"new",
"NetConn",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/net_conn.go#L16-L21 |
9,942 | 256dpi/gomqtt | transport/launcher.go | Launch | func (l *Launcher) Launch(urlString string) (Server, error) {
urlParts, err := url.ParseRequestURI(urlString)
if err != nil {
return nil, err
}
switch urlParts.Scheme {
case "tcp", "mqtt":
return CreateNetServer(urlParts.Host)
case "tls", "mqtts":
return CreateSecureNetServer(urlParts.Host, l.TLSConfig)
case "ws":
return CreateWebSocketServer(urlParts.Host)
case "wss":
return CreateSecureWebSocketServer(urlParts.Host, l.TLSConfig)
}
return nil, ErrUnsupportedProtocol
} | go | func (l *Launcher) Launch(urlString string) (Server, error) {
urlParts, err := url.ParseRequestURI(urlString)
if err != nil {
return nil, err
}
switch urlParts.Scheme {
case "tcp", "mqtt":
return CreateNetServer(urlParts.Host)
case "tls", "mqtts":
return CreateSecureNetServer(urlParts.Host, l.TLSConfig)
case "ws":
return CreateWebSocketServer(urlParts.Host)
case "wss":
return CreateSecureWebSocketServer(urlParts.Host, l.TLSConfig)
}
return nil, ErrUnsupportedProtocol
} | [
"func",
"(",
"l",
"*",
"Launcher",
")",
"Launch",
"(",
"urlString",
"string",
")",
"(",
"Server",
",",
"error",
")",
"{",
"urlParts",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"urlString",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"urlParts",
".",
"Scheme",
"{",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"CreateNetServer",
"(",
"urlParts",
".",
"Host",
")",
"\n",
"case",
"\"",
"\"",
",",
"\"",
"\"",
":",
"return",
"CreateSecureNetServer",
"(",
"urlParts",
".",
"Host",
",",
"l",
".",
"TLSConfig",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"CreateWebSocketServer",
"(",
"urlParts",
".",
"Host",
")",
"\n",
"case",
"\"",
"\"",
":",
"return",
"CreateSecureWebSocketServer",
"(",
"urlParts",
".",
"Host",
",",
"l",
".",
"TLSConfig",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
",",
"ErrUnsupportedProtocol",
"\n",
"}"
] | // Launch will launch a server based on information extracted from an URL. | [
"Launch",
"will",
"launch",
"a",
"server",
"based",
"on",
"information",
"extracted",
"from",
"an",
"URL",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/launcher.go#L30-L48 |
9,943 | 256dpi/gomqtt | client/tracker.go | NewTracker | func NewTracker(timeout time.Duration) *Tracker {
return &Tracker{
last: time.Now(),
timeout: timeout,
}
} | go | func NewTracker(timeout time.Duration) *Tracker {
return &Tracker{
last: time.Now(),
timeout: timeout,
}
} | [
"func",
"NewTracker",
"(",
"timeout",
"time",
".",
"Duration",
")",
"*",
"Tracker",
"{",
"return",
"&",
"Tracker",
"{",
"last",
":",
"time",
".",
"Now",
"(",
")",
",",
"timeout",
":",
"timeout",
",",
"}",
"\n",
"}"
] | // NewTracker returns a new tracker. | [
"NewTracker",
"returns",
"a",
"new",
"tracker",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tracker.go#L18-L23 |
9,944 | 256dpi/gomqtt | client/tracker.go | Reset | func (t *Tracker) Reset() {
t.Lock()
defer t.Unlock()
t.last = time.Now()
} | go | func (t *Tracker) Reset() {
t.Lock()
defer t.Unlock()
t.last = time.Now()
} | [
"func",
"(",
"t",
"*",
"Tracker",
")",
"Reset",
"(",
")",
"{",
"t",
".",
"Lock",
"(",
")",
"\n",
"defer",
"t",
".",
"Unlock",
"(",
")",
"\n\n",
"t",
".",
"last",
"=",
"time",
".",
"Now",
"(",
")",
"\n",
"}"
] | // Reset will reset the tracker. | [
"Reset",
"will",
"reset",
"the",
"tracker",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tracker.go#L26-L31 |
9,945 | 256dpi/gomqtt | client/tracker.go | Window | func (t *Tracker) Window() time.Duration {
t.RLock()
defer t.RUnlock()
return t.timeout - time.Since(t.last)
} | go | func (t *Tracker) Window() time.Duration {
t.RLock()
defer t.RUnlock()
return t.timeout - time.Since(t.last)
} | [
"func",
"(",
"t",
"*",
"Tracker",
")",
"Window",
"(",
")",
"time",
".",
"Duration",
"{",
"t",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"t",
".",
"timeout",
"-",
"time",
".",
"Since",
"(",
"t",
".",
"last",
")",
"\n",
"}"
] | // Window returns the time until a new ping should be sent. | [
"Window",
"returns",
"the",
"time",
"until",
"a",
"new",
"ping",
"should",
"be",
"sent",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tracker.go#L34-L39 |
9,946 | 256dpi/gomqtt | client/tracker.go | Pending | func (t *Tracker) Pending() bool {
t.RLock()
defer t.RUnlock()
return t.pings > 0
} | go | func (t *Tracker) Pending() bool {
t.RLock()
defer t.RUnlock()
return t.pings > 0
} | [
"func",
"(",
"t",
"*",
"Tracker",
")",
"Pending",
"(",
")",
"bool",
"{",
"t",
".",
"RLock",
"(",
")",
"\n",
"defer",
"t",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"t",
".",
"pings",
">",
"0",
"\n",
"}"
] | // Pending returns if pings are pending. | [
"Pending",
"returns",
"if",
"pings",
"are",
"pending",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/tracker.go#L58-L63 |
9,947 | 256dpi/gomqtt | session/id_counter.go | NextID | func (c *IDCounter) NextID() packet.ID {
c.mutex.Lock()
defer c.mutex.Unlock()
// ignore zeroes
if c.next == 0 {
c.next++
}
// cache next id
id := c.next
// increment id
c.next++
return id
} | go | func (c *IDCounter) NextID() packet.ID {
c.mutex.Lock()
defer c.mutex.Unlock()
// ignore zeroes
if c.next == 0 {
c.next++
}
// cache next id
id := c.next
// increment id
c.next++
return id
} | [
"func",
"(",
"c",
"*",
"IDCounter",
")",
"NextID",
"(",
")",
"packet",
".",
"ID",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// ignore zeroes",
"if",
"c",
".",
"next",
"==",
"0",
"{",
"c",
".",
"next",
"++",
"\n",
"}",
"\n\n",
"// cache next id",
"id",
":=",
"c",
".",
"next",
"\n\n",
"// increment id",
"c",
".",
"next",
"++",
"\n\n",
"return",
"id",
"\n",
"}"
] | // NextID will return the next id. | [
"NextID",
"will",
"return",
"the",
"next",
"id",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/id_counter.go#L29-L45 |
9,948 | 256dpi/gomqtt | session/id_counter.go | Reset | func (c *IDCounter) Reset() {
c.mutex.Lock()
defer c.mutex.Unlock()
c.next = 1
} | go | func (c *IDCounter) Reset() {
c.mutex.Lock()
defer c.mutex.Unlock()
c.next = 1
} | [
"func",
"(",
"c",
"*",
"IDCounter",
")",
"Reset",
"(",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"c",
".",
"next",
"=",
"1",
"\n",
"}"
] | // Reset will reset the counter. | [
"Reset",
"will",
"reset",
"the",
"counter",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/id_counter.go#L48-L53 |
9,949 | 256dpi/gomqtt | transport/flow/flow.go | Send | func (conn *Pipe) Send(pkt packet.Generic, _ bool) error {
select {
case conn.pipe <- pkt:
return nil
case <-conn.close:
return errors.New("closed")
}
} | go | func (conn *Pipe) Send(pkt packet.Generic, _ bool) error {
select {
case conn.pipe <- pkt:
return nil
case <-conn.close:
return errors.New("closed")
}
} | [
"func",
"(",
"conn",
"*",
"Pipe",
")",
"Send",
"(",
"pkt",
"packet",
".",
"Generic",
",",
"_",
"bool",
")",
"error",
"{",
"select",
"{",
"case",
"conn",
".",
"pipe",
"<-",
"pkt",
":",
"return",
"nil",
"\n",
"case",
"<-",
"conn",
".",
"close",
":",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // Send returns packet on next Receive call. | [
"Send",
"returns",
"packet",
"on",
"next",
"Receive",
"call",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L36-L43 |
9,950 | 256dpi/gomqtt | transport/flow/flow.go | Receive | func (conn *Pipe) Receive() (packet.Generic, error) {
select {
case pkt := <-conn.pipe:
return pkt, nil
case <-conn.close:
return nil, io.EOF
}
} | go | func (conn *Pipe) Receive() (packet.Generic, error) {
select {
case pkt := <-conn.pipe:
return pkt, nil
case <-conn.close:
return nil, io.EOF
}
} | [
"func",
"(",
"conn",
"*",
"Pipe",
")",
"Receive",
"(",
")",
"(",
"packet",
".",
"Generic",
",",
"error",
")",
"{",
"select",
"{",
"case",
"pkt",
":=",
"<-",
"conn",
".",
"pipe",
":",
"return",
"pkt",
",",
"nil",
"\n",
"case",
"<-",
"conn",
".",
"close",
":",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"}",
"\n",
"}"
] | // Receive returns the packet being sent with Send. | [
"Receive",
"returns",
"the",
"packet",
"being",
"sent",
"with",
"Send",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L46-L53 |
9,951 | 256dpi/gomqtt | transport/flow/flow.go | Send | func (f *Flow) Send(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionSend,
packets: pkts,
})
return f
} | go | func (f *Flow) Send(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionSend,
packets: pkts,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"Send",
"(",
"pkts",
"...",
"packet",
".",
"Generic",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionSend",
",",
"packets",
":",
"pkts",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Send will send the specified packets. | [
"Send",
"will",
"send",
"the",
"specified",
"packets",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L100-L107 |
9,952 | 256dpi/gomqtt | transport/flow/flow.go | Receive | func (f *Flow) Receive(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionReceive,
packets: pkts,
})
return f
} | go | func (f *Flow) Receive(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionReceive,
packets: pkts,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"Receive",
"(",
"pkts",
"...",
"packet",
".",
"Generic",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionReceive",
",",
"packets",
":",
"pkts",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Receive will receive and match the specified packets out of order. | [
"Receive",
"will",
"receive",
"and",
"match",
"the",
"specified",
"packets",
"out",
"of",
"order",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L110-L117 |
9,953 | 256dpi/gomqtt | transport/flow/flow.go | Skip | func (f *Flow) Skip(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionSkip,
packets: pkts,
})
return f
} | go | func (f *Flow) Skip(pkts ...packet.Generic) *Flow {
f.add(action{
kind: actionSkip,
packets: pkts,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"Skip",
"(",
"pkts",
"...",
"packet",
".",
"Generic",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionSkip",
",",
"packets",
":",
"pkts",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Skip will receive the specified packets without matching out of order. | [
"Skip",
"will",
"receive",
"the",
"specified",
"packets",
"without",
"matching",
"out",
"of",
"order",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L120-L127 |
9,954 | 256dpi/gomqtt | transport/flow/flow.go | Run | func (f *Flow) Run(fn func()) *Flow {
f.add(action{
kind: actionRun,
fn: fn,
})
return f
} | go | func (f *Flow) Run(fn func()) *Flow {
f.add(action{
kind: actionRun,
fn: fn,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"Run",
"(",
"fn",
"func",
"(",
")",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionRun",
",",
"fn",
":",
"fn",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Run will call the supplied function and wait until it returns. | [
"Run",
"will",
"call",
"the",
"supplied",
"function",
"and",
"wait",
"until",
"it",
"returns",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L130-L137 |
9,955 | 256dpi/gomqtt | transport/flow/flow.go | Close | func (f *Flow) Close() *Flow {
f.add(action{
kind: actionClose,
})
return f
} | go | func (f *Flow) Close() *Flow {
f.add(action{
kind: actionClose,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"Close",
"(",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionClose",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // Close will immediately close the connection. | [
"Close",
"will",
"immediately",
"close",
"the",
"connection",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L140-L146 |
9,956 | 256dpi/gomqtt | transport/flow/flow.go | End | func (f *Flow) End() *Flow {
f.add(action{
kind: actionEnd,
})
return f
} | go | func (f *Flow) End() *Flow {
f.add(action{
kind: actionEnd,
})
return f
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"End",
"(",
")",
"*",
"Flow",
"{",
"f",
".",
"add",
"(",
"action",
"{",
"kind",
":",
"actionEnd",
",",
"}",
")",
"\n\n",
"return",
"f",
"\n",
"}"
] | // End will match proper connection close. | [
"End",
"will",
"match",
"proper",
"connection",
"close",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L149-L155 |
9,957 | 256dpi/gomqtt | transport/flow/flow.go | add | func (f *Flow) add(action action) {
f.actions = append(f.actions, action)
} | go | func (f *Flow) add(action action) {
f.actions = append(f.actions, action)
} | [
"func",
"(",
"f",
"*",
"Flow",
")",
"add",
"(",
"action",
"action",
")",
"{",
"f",
".",
"actions",
"=",
"append",
"(",
"f",
".",
"actions",
",",
"action",
")",
"\n",
"}"
] | // add will add the specified action. | [
"add",
"will",
"add",
"the",
"specified",
"action",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/flow/flow.go#L304-L306 |
9,958 | 256dpi/gomqtt | session/memory_session.go | SavePacket | func (s *MemorySession) SavePacket(dir Direction, pkt packet.Generic) error {
s.storeForDirection(dir).Save(pkt)
return nil
} | go | func (s *MemorySession) SavePacket(dir Direction, pkt packet.Generic) error {
s.storeForDirection(dir).Save(pkt)
return nil
} | [
"func",
"(",
"s",
"*",
"MemorySession",
")",
"SavePacket",
"(",
"dir",
"Direction",
",",
"pkt",
"packet",
".",
"Generic",
")",
"error",
"{",
"s",
".",
"storeForDirection",
"(",
"dir",
")",
".",
"Save",
"(",
"pkt",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // SavePacket will store a packet in the session. An eventual existing
// packet with the same id gets quietly overwritten. | [
"SavePacket",
"will",
"store",
"a",
"packet",
"in",
"the",
"session",
".",
"An",
"eventual",
"existing",
"packet",
"with",
"the",
"same",
"id",
"gets",
"quietly",
"overwritten",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/memory_session.go#L43-L46 |
9,959 | 256dpi/gomqtt | session/memory_session.go | LookupPacket | func (s *MemorySession) LookupPacket(dir Direction, id packet.ID) (packet.Generic, error) {
return s.storeForDirection(dir).Lookup(id), nil
} | go | func (s *MemorySession) LookupPacket(dir Direction, id packet.ID) (packet.Generic, error) {
return s.storeForDirection(dir).Lookup(id), nil
} | [
"func",
"(",
"s",
"*",
"MemorySession",
")",
"LookupPacket",
"(",
"dir",
"Direction",
",",
"id",
"packet",
".",
"ID",
")",
"(",
"packet",
".",
"Generic",
",",
"error",
")",
"{",
"return",
"s",
".",
"storeForDirection",
"(",
"dir",
")",
".",
"Lookup",
"(",
"id",
")",
",",
"nil",
"\n",
"}"
] | // LookupPacket will retrieve a packet from the session using a packet id. | [
"LookupPacket",
"will",
"retrieve",
"a",
"packet",
"from",
"the",
"session",
"using",
"a",
"packet",
"id",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/memory_session.go#L49-L51 |
9,960 | 256dpi/gomqtt | session/memory_session.go | DeletePacket | func (s *MemorySession) DeletePacket(dir Direction, id packet.ID) error {
s.storeForDirection(dir).Delete(id)
return nil
} | go | func (s *MemorySession) DeletePacket(dir Direction, id packet.ID) error {
s.storeForDirection(dir).Delete(id)
return nil
} | [
"func",
"(",
"s",
"*",
"MemorySession",
")",
"DeletePacket",
"(",
"dir",
"Direction",
",",
"id",
"packet",
".",
"ID",
")",
"error",
"{",
"s",
".",
"storeForDirection",
"(",
"dir",
")",
".",
"Delete",
"(",
"id",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // DeletePacket will remove a packet from the session. The method must not
// return an error if no packet with the specified id does exists. | [
"DeletePacket",
"will",
"remove",
"a",
"packet",
"from",
"the",
"session",
".",
"The",
"method",
"must",
"not",
"return",
"an",
"error",
"if",
"no",
"packet",
"with",
"the",
"specified",
"id",
"does",
"exists",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/memory_session.go#L55-L58 |
9,961 | 256dpi/gomqtt | session/memory_session.go | AllPackets | func (s *MemorySession) AllPackets(dir Direction) ([]packet.Generic, error) {
return s.storeForDirection(dir).All(), nil
} | go | func (s *MemorySession) AllPackets(dir Direction) ([]packet.Generic, error) {
return s.storeForDirection(dir).All(), nil
} | [
"func",
"(",
"s",
"*",
"MemorySession",
")",
"AllPackets",
"(",
"dir",
"Direction",
")",
"(",
"[",
"]",
"packet",
".",
"Generic",
",",
"error",
")",
"{",
"return",
"s",
".",
"storeForDirection",
"(",
"dir",
")",
".",
"All",
"(",
")",
",",
"nil",
"\n",
"}"
] | // AllPackets will return all packets currently saved in the session. | [
"AllPackets",
"will",
"return",
"all",
"packets",
"currently",
"saved",
"in",
"the",
"session",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/memory_session.go#L61-L63 |
9,962 | 256dpi/gomqtt | session/memory_session.go | Reset | func (s *MemorySession) Reset() error {
// reset counter and stores
s.Counter.Reset()
s.Incoming.Reset()
s.Outgoing.Reset()
return nil
} | go | func (s *MemorySession) Reset() error {
// reset counter and stores
s.Counter.Reset()
s.Incoming.Reset()
s.Outgoing.Reset()
return nil
} | [
"func",
"(",
"s",
"*",
"MemorySession",
")",
"Reset",
"(",
")",
"error",
"{",
"// reset counter and stores",
"s",
".",
"Counter",
".",
"Reset",
"(",
")",
"\n",
"s",
".",
"Incoming",
".",
"Reset",
"(",
")",
"\n",
"s",
".",
"Outgoing",
".",
"Reset",
"(",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Reset will completely reset the session. | [
"Reset",
"will",
"completely",
"reset",
"the",
"session",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/memory_session.go#L66-L73 |
9,963 | 256dpi/gomqtt | packet/stream.go | NewEncoder | func NewEncoder(writer io.Writer, maxWriteDelay time.Duration) *Encoder {
return &Encoder{
writer: mercury.NewWriter(writer, maxWriteDelay),
}
} | go | func NewEncoder(writer io.Writer, maxWriteDelay time.Duration) *Encoder {
return &Encoder{
writer: mercury.NewWriter(writer, maxWriteDelay),
}
} | [
"func",
"NewEncoder",
"(",
"writer",
"io",
".",
"Writer",
",",
"maxWriteDelay",
"time",
".",
"Duration",
")",
"*",
"Encoder",
"{",
"return",
"&",
"Encoder",
"{",
"writer",
":",
"mercury",
".",
"NewWriter",
"(",
"writer",
",",
"maxWriteDelay",
")",
",",
"}",
"\n",
"}"
] | // NewEncoder creates a new Encoder. | [
"NewEncoder",
"creates",
"a",
"new",
"Encoder",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/stream.go#L28-L32 |
9,964 | 256dpi/gomqtt | packet/stream.go | Write | func (e *Encoder) Write(pkt Generic, async bool) error {
// reset and eventually grow buffer
packetLength := pkt.Len()
e.buffer.Reset()
e.buffer.Grow(packetLength)
buf := e.buffer.Bytes()[0:packetLength]
// encode packet
_, err := pkt.Encode(buf)
if err != nil {
return err
}
// write buffer
if async {
_, err = e.writer.Write(buf)
} else {
_, err = e.writer.WriteAndFlush(buf)
}
if err != nil {
return err
}
return nil
} | go | func (e *Encoder) Write(pkt Generic, async bool) error {
// reset and eventually grow buffer
packetLength := pkt.Len()
e.buffer.Reset()
e.buffer.Grow(packetLength)
buf := e.buffer.Bytes()[0:packetLength]
// encode packet
_, err := pkt.Encode(buf)
if err != nil {
return err
}
// write buffer
if async {
_, err = e.writer.Write(buf)
} else {
_, err = e.writer.WriteAndFlush(buf)
}
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"e",
"*",
"Encoder",
")",
"Write",
"(",
"pkt",
"Generic",
",",
"async",
"bool",
")",
"error",
"{",
"// reset and eventually grow buffer",
"packetLength",
":=",
"pkt",
".",
"Len",
"(",
")",
"\n",
"e",
".",
"buffer",
".",
"Reset",
"(",
")",
"\n",
"e",
".",
"buffer",
".",
"Grow",
"(",
"packetLength",
")",
"\n",
"buf",
":=",
"e",
".",
"buffer",
".",
"Bytes",
"(",
")",
"[",
"0",
":",
"packetLength",
"]",
"\n\n",
"// encode packet",
"_",
",",
"err",
":=",
"pkt",
".",
"Encode",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// write buffer",
"if",
"async",
"{",
"_",
",",
"err",
"=",
"e",
".",
"writer",
".",
"Write",
"(",
"buf",
")",
"\n",
"}",
"else",
"{",
"_",
",",
"err",
"=",
"e",
".",
"writer",
".",
"WriteAndFlush",
"(",
"buf",
")",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Write encodes and writes the passed packet to the write buffer. | [
"Write",
"encodes",
"and",
"writes",
"the",
"passed",
"packet",
"to",
"the",
"write",
"buffer",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/stream.go#L35-L59 |
9,965 | 256dpi/gomqtt | packet/stream.go | NewDecoder | func NewDecoder(reader io.Reader) *Decoder {
return &Decoder{
reader: bufio.NewReader(reader),
}
} | go | func NewDecoder(reader io.Reader) *Decoder {
return &Decoder{
reader: bufio.NewReader(reader),
}
} | [
"func",
"NewDecoder",
"(",
"reader",
"io",
".",
"Reader",
")",
"*",
"Decoder",
"{",
"return",
"&",
"Decoder",
"{",
"reader",
":",
"bufio",
".",
"NewReader",
"(",
"reader",
")",
",",
"}",
"\n",
"}"
] | // NewDecoder returns a new Decoder. | [
"NewDecoder",
"returns",
"a",
"new",
"Decoder",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/stream.go#L75-L79 |
9,966 | 256dpi/gomqtt | packet/stream.go | Read | func (d *Decoder) Read() (Generic, error) {
// initial detection length
detectionLength := 2
for {
// check length
if detectionLength > 5 {
return nil, ErrDetectionOverflow
}
// try read detection bytes
header, err := d.reader.Peek(detectionLength)
if err == io.EOF && len(header) != 0 {
// an EOF with some data is unexpected
return nil, io.ErrUnexpectedEOF
} else if err != nil {
return nil, err
}
// detect packet
packetLength, packetType := DetectPacket(header)
// on zero packet length:
// increment detection length and try again
if packetLength <= 0 {
detectionLength++
continue
}
// check read limit
if d.Limit > 0 && int64(packetLength) > d.Limit {
return nil, ErrReadLimitExceeded
}
// create packet
pkt, err := packetType.New()
if err != nil {
return nil, err
}
// reset and eventually grow buffer
d.buffer.Reset()
d.buffer.Grow(packetLength)
buf := d.buffer.Bytes()[0:packetLength]
// read whole packet (will not return EOF)
_, err = io.ReadFull(d.reader, buf)
if err != nil {
return nil, err
}
// decode buffer
_, err = pkt.Decode(buf)
if err != nil {
return nil, err
}
return pkt, nil
}
} | go | func (d *Decoder) Read() (Generic, error) {
// initial detection length
detectionLength := 2
for {
// check length
if detectionLength > 5 {
return nil, ErrDetectionOverflow
}
// try read detection bytes
header, err := d.reader.Peek(detectionLength)
if err == io.EOF && len(header) != 0 {
// an EOF with some data is unexpected
return nil, io.ErrUnexpectedEOF
} else if err != nil {
return nil, err
}
// detect packet
packetLength, packetType := DetectPacket(header)
// on zero packet length:
// increment detection length and try again
if packetLength <= 0 {
detectionLength++
continue
}
// check read limit
if d.Limit > 0 && int64(packetLength) > d.Limit {
return nil, ErrReadLimitExceeded
}
// create packet
pkt, err := packetType.New()
if err != nil {
return nil, err
}
// reset and eventually grow buffer
d.buffer.Reset()
d.buffer.Grow(packetLength)
buf := d.buffer.Bytes()[0:packetLength]
// read whole packet (will not return EOF)
_, err = io.ReadFull(d.reader, buf)
if err != nil {
return nil, err
}
// decode buffer
_, err = pkt.Decode(buf)
if err != nil {
return nil, err
}
return pkt, nil
}
} | [
"func",
"(",
"d",
"*",
"Decoder",
")",
"Read",
"(",
")",
"(",
"Generic",
",",
"error",
")",
"{",
"// initial detection length",
"detectionLength",
":=",
"2",
"\n\n",
"for",
"{",
"// check length",
"if",
"detectionLength",
">",
"5",
"{",
"return",
"nil",
",",
"ErrDetectionOverflow",
"\n",
"}",
"\n\n",
"// try read detection bytes",
"header",
",",
"err",
":=",
"d",
".",
"reader",
".",
"Peek",
"(",
"detectionLength",
")",
"\n",
"if",
"err",
"==",
"io",
".",
"EOF",
"&&",
"len",
"(",
"header",
")",
"!=",
"0",
"{",
"// an EOF with some data is unexpected",
"return",
"nil",
",",
"io",
".",
"ErrUnexpectedEOF",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// detect packet",
"packetLength",
",",
"packetType",
":=",
"DetectPacket",
"(",
"header",
")",
"\n\n",
"// on zero packet length:",
"// increment detection length and try again",
"if",
"packetLength",
"<=",
"0",
"{",
"detectionLength",
"++",
"\n",
"continue",
"\n",
"}",
"\n\n",
"// check read limit",
"if",
"d",
".",
"Limit",
">",
"0",
"&&",
"int64",
"(",
"packetLength",
")",
">",
"d",
".",
"Limit",
"{",
"return",
"nil",
",",
"ErrReadLimitExceeded",
"\n",
"}",
"\n\n",
"// create packet",
"pkt",
",",
"err",
":=",
"packetType",
".",
"New",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// reset and eventually grow buffer",
"d",
".",
"buffer",
".",
"Reset",
"(",
")",
"\n",
"d",
".",
"buffer",
".",
"Grow",
"(",
"packetLength",
")",
"\n",
"buf",
":=",
"d",
".",
"buffer",
".",
"Bytes",
"(",
")",
"[",
"0",
":",
"packetLength",
"]",
"\n\n",
"// read whole packet (will not return EOF)",
"_",
",",
"err",
"=",
"io",
".",
"ReadFull",
"(",
"d",
".",
"reader",
",",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// decode buffer",
"_",
",",
"err",
"=",
"pkt",
".",
"Decode",
"(",
"buf",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"pkt",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // Read reads the next packet from the buffered reader. | [
"Read",
"reads",
"the",
"next",
"packet",
"from",
"the",
"buffered",
"reader",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/stream.go#L82-L141 |
9,967 | 256dpi/gomqtt | packet/stream.go | NewStream | func NewStream(reader io.Reader, writer io.Writer, maxWriteDelay time.Duration) *Stream {
return &Stream{
Decoder: NewDecoder(reader),
Encoder: NewEncoder(writer, maxWriteDelay),
}
} | go | func NewStream(reader io.Reader, writer io.Writer, maxWriteDelay time.Duration) *Stream {
return &Stream{
Decoder: NewDecoder(reader),
Encoder: NewEncoder(writer, maxWriteDelay),
}
} | [
"func",
"NewStream",
"(",
"reader",
"io",
".",
"Reader",
",",
"writer",
"io",
".",
"Writer",
",",
"maxWriteDelay",
"time",
".",
"Duration",
")",
"*",
"Stream",
"{",
"return",
"&",
"Stream",
"{",
"Decoder",
":",
"NewDecoder",
"(",
"reader",
")",
",",
"Encoder",
":",
"NewEncoder",
"(",
"writer",
",",
"maxWriteDelay",
")",
",",
"}",
"\n",
"}"
] | // NewStream creates a new Stream. | [
"NewStream",
"creates",
"a",
"new",
"Stream",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/stream.go#L150-L155 |
9,968 | 256dpi/gomqtt | packet/message.go | String | func (m *Message) String() string {
return fmt.Sprintf("<Message Topic=%q QOS=%d Retain=%t Payload=%v>",
m.Topic, m.QOS, m.Retain, m.Payload)
} | go | func (m *Message) String() string {
return fmt.Sprintf("<Message Topic=%q QOS=%d Retain=%t Payload=%v>",
m.Topic, m.QOS, m.Retain, m.Payload)
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"Topic",
",",
"m",
".",
"QOS",
",",
"m",
".",
"Retain",
",",
"m",
".",
"Payload",
")",
"\n",
"}"
] | // String returns a string representation of the message. | [
"String",
"returns",
"a",
"string",
"representation",
"of",
"the",
"message",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/message.go#L23-L26 |
9,969 | 256dpi/gomqtt | topic/topic.go | Parse | func Parse(topic string, allowWildcards bool) (string, error) {
// check for zero length
if topic == "" {
return "", ErrZeroLength
}
// normalize topic
topic = multiSlashRegex.ReplaceAllString(topic, "/")
// remove trailing slashes
topic = strings.TrimRight(topic, "/")
// check again for zero length
if topic == "" {
return "", ErrZeroLength
}
// split to segments
segments := strings.Split(topic, "/")
// check all segments
for i, s := range segments {
// check use of wildcards
if (strings.Contains(s, "+") || strings.Contains(s, "#")) && len(s) > 1 {
return "", ErrWildcards
}
// check if wildcards are allowed
if !allowWildcards && (s == "#" || s == "+") {
return "", ErrWildcards
}
// check if hash is the last character
if s == "#" && i != len(segments)-1 {
return "", ErrWildcards
}
}
return topic, nil
} | go | func Parse(topic string, allowWildcards bool) (string, error) {
// check for zero length
if topic == "" {
return "", ErrZeroLength
}
// normalize topic
topic = multiSlashRegex.ReplaceAllString(topic, "/")
// remove trailing slashes
topic = strings.TrimRight(topic, "/")
// check again for zero length
if topic == "" {
return "", ErrZeroLength
}
// split to segments
segments := strings.Split(topic, "/")
// check all segments
for i, s := range segments {
// check use of wildcards
if (strings.Contains(s, "+") || strings.Contains(s, "#")) && len(s) > 1 {
return "", ErrWildcards
}
// check if wildcards are allowed
if !allowWildcards && (s == "#" || s == "+") {
return "", ErrWildcards
}
// check if hash is the last character
if s == "#" && i != len(segments)-1 {
return "", ErrWildcards
}
}
return topic, nil
} | [
"func",
"Parse",
"(",
"topic",
"string",
",",
"allowWildcards",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"// check for zero length",
"if",
"topic",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrZeroLength",
"\n",
"}",
"\n\n",
"// normalize topic",
"topic",
"=",
"multiSlashRegex",
".",
"ReplaceAllString",
"(",
"topic",
",",
"\"",
"\"",
")",
"\n\n",
"// remove trailing slashes",
"topic",
"=",
"strings",
".",
"TrimRight",
"(",
"topic",
",",
"\"",
"\"",
")",
"\n\n",
"// check again for zero length",
"if",
"topic",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
",",
"ErrZeroLength",
"\n",
"}",
"\n\n",
"// split to segments",
"segments",
":=",
"strings",
".",
"Split",
"(",
"topic",
",",
"\"",
"\"",
")",
"\n\n",
"// check all segments",
"for",
"i",
",",
"s",
":=",
"range",
"segments",
"{",
"// check use of wildcards",
"if",
"(",
"strings",
".",
"Contains",
"(",
"s",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"s",
",",
"\"",
"\"",
")",
")",
"&&",
"len",
"(",
"s",
")",
">",
"1",
"{",
"return",
"\"",
"\"",
",",
"ErrWildcards",
"\n",
"}",
"\n\n",
"// check if wildcards are allowed",
"if",
"!",
"allowWildcards",
"&&",
"(",
"s",
"==",
"\"",
"\"",
"||",
"s",
"==",
"\"",
"\"",
")",
"{",
"return",
"\"",
"\"",
",",
"ErrWildcards",
"\n",
"}",
"\n\n",
"// check if hash is the last character",
"if",
"s",
"==",
"\"",
"\"",
"&&",
"i",
"!=",
"len",
"(",
"segments",
")",
"-",
"1",
"{",
"return",
"\"",
"\"",
",",
"ErrWildcards",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"topic",
",",
"nil",
"\n",
"}"
] | // Parse removes duplicate and trailing slashes from the supplied
// string and returns the normalized topic. | [
"Parse",
"removes",
"duplicate",
"and",
"trailing",
"slashes",
"from",
"the",
"supplied",
"string",
"and",
"returns",
"the",
"normalized",
"topic",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/topic.go#L20-L59 |
9,970 | 256dpi/gomqtt | topic/topic.go | ContainsWildcards | func ContainsWildcards(topic string) bool {
return strings.Contains(topic, "+") || strings.Contains(topic, "#")
} | go | func ContainsWildcards(topic string) bool {
return strings.Contains(topic, "+") || strings.Contains(topic, "#")
} | [
"func",
"ContainsWildcards",
"(",
"topic",
"string",
")",
"bool",
"{",
"return",
"strings",
".",
"Contains",
"(",
"topic",
",",
"\"",
"\"",
")",
"||",
"strings",
".",
"Contains",
"(",
"topic",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // ContainsWildcards tests if the supplied topic contains wildcards. The topics
// is expected to be tested and normalized using Parse beforehand. | [
"ContainsWildcards",
"tests",
"if",
"the",
"supplied",
"topic",
"contains",
"wildcards",
".",
"The",
"topics",
"is",
"expected",
"to",
"be",
"tested",
"and",
"normalized",
"using",
"Parse",
"beforehand",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/topic/topic.go#L63-L65 |
9,971 | 256dpi/gomqtt | packet/naked.go | nakedDecode | func nakedDecode(src []byte, t Type) (int, error) {
// decode header
hl, _, rl, err := headerDecode(src, t)
// check remaining length
if rl != 0 {
return hl, makeError(t, "expected zero remaining length")
}
return hl, err
} | go | func nakedDecode(src []byte, t Type) (int, error) {
// decode header
hl, _, rl, err := headerDecode(src, t)
// check remaining length
if rl != 0 {
return hl, makeError(t, "expected zero remaining length")
}
return hl, err
} | [
"func",
"nakedDecode",
"(",
"src",
"[",
"]",
"byte",
",",
"t",
"Type",
")",
"(",
"int",
",",
"error",
")",
"{",
"// decode header",
"hl",
",",
"_",
",",
"rl",
",",
"err",
":=",
"headerDecode",
"(",
"src",
",",
"t",
")",
"\n\n",
"// check remaining length",
"if",
"rl",
"!=",
"0",
"{",
"return",
"hl",
",",
"makeError",
"(",
"t",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"return",
"hl",
",",
"err",
"\n",
"}"
] | // decodes a naked packet | [
"decodes",
"a",
"naked",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/naked.go#L9-L19 |
9,972 | 256dpi/gomqtt | packet/naked.go | nakedEncode | func nakedEncode(dst []byte, t Type) (int, error) {
// encode header
return headerEncode(dst, 0, 0, nakedLen(), t)
} | go | func nakedEncode(dst []byte, t Type) (int, error) {
// encode header
return headerEncode(dst, 0, 0, nakedLen(), t)
} | [
"func",
"nakedEncode",
"(",
"dst",
"[",
"]",
"byte",
",",
"t",
"Type",
")",
"(",
"int",
",",
"error",
")",
"{",
"// encode header",
"return",
"headerEncode",
"(",
"dst",
",",
"0",
",",
"0",
",",
"nakedLen",
"(",
")",
",",
"t",
")",
"\n",
"}"
] | // encodes a naked packet | [
"encodes",
"a",
"naked",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/packet/naked.go#L22-L25 |
9,973 | 256dpi/gomqtt | client/future/store.go | Put | func (s *Store) Put(id packet.ID, future *Future) {
s.Lock()
defer s.Unlock()
s.store[id] = future
} | go | func (s *Store) Put(id packet.ID, future *Future) {
s.Lock()
defer s.Unlock()
s.store[id] = future
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Put",
"(",
"id",
"packet",
".",
"ID",
",",
"future",
"*",
"Future",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"store",
"[",
"id",
"]",
"=",
"future",
"\n",
"}"
] | // Put will save a future to the store. | [
"Put",
"will",
"save",
"a",
"future",
"to",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L26-L31 |
9,974 | 256dpi/gomqtt | client/future/store.go | Get | func (s *Store) Get(id packet.ID) *Future {
s.RLock()
defer s.RUnlock()
return s.store[id]
} | go | func (s *Store) Get(id packet.ID) *Future {
s.RLock()
defer s.RUnlock()
return s.store[id]
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Get",
"(",
"id",
"packet",
".",
"ID",
")",
"*",
"Future",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"store",
"[",
"id",
"]",
"\n",
"}"
] | // Get will retrieve a future from the store. | [
"Get",
"will",
"retrieve",
"a",
"future",
"from",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L34-L39 |
9,975 | 256dpi/gomqtt | client/future/store.go | Delete | func (s *Store) Delete(id packet.ID) {
s.Lock()
defer s.Unlock()
delete(s.store, id)
} | go | func (s *Store) Delete(id packet.ID) {
s.Lock()
defer s.Unlock()
delete(s.store, id)
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Delete",
"(",
"id",
"packet",
".",
"ID",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"s",
".",
"store",
",",
"id",
")",
"\n",
"}"
] | // Delete will remove a future from the store. | [
"Delete",
"will",
"remove",
"a",
"future",
"from",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L42-L47 |
9,976 | 256dpi/gomqtt | client/future/store.go | All | func (s *Store) All() []*Future {
s.RLock()
defer s.RUnlock()
all := make([]*Future, 0, len(s.store))
for _, savedFuture := range s.store {
all = append(all, savedFuture)
}
return all
} | go | func (s *Store) All() []*Future {
s.RLock()
defer s.RUnlock()
all := make([]*Future, 0, len(s.store))
for _, savedFuture := range s.store {
all = append(all, savedFuture)
}
return all
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"All",
"(",
")",
"[",
"]",
"*",
"Future",
"{",
"s",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"all",
":=",
"make",
"(",
"[",
"]",
"*",
"Future",
",",
"0",
",",
"len",
"(",
"s",
".",
"store",
")",
")",
"\n\n",
"for",
"_",
",",
"savedFuture",
":=",
"range",
"s",
".",
"store",
"{",
"all",
"=",
"append",
"(",
"all",
",",
"savedFuture",
")",
"\n",
"}",
"\n\n",
"return",
"all",
"\n",
"}"
] | // All will return a slice with all stored futures. | [
"All",
"will",
"return",
"a",
"slice",
"with",
"all",
"stored",
"futures",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L50-L61 |
9,977 | 256dpi/gomqtt | client/future/store.go | Protect | func (s *Store) Protect(value bool) {
s.Lock()
defer s.Unlock()
s.protected = value
} | go | func (s *Store) Protect(value bool) {
s.Lock()
defer s.Unlock()
s.protected = value
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Protect",
"(",
"value",
"bool",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"protected",
"=",
"value",
"\n",
"}"
] | // Protect will set the protection attribute and if true prevents the store from
// being cleared. | [
"Protect",
"will",
"set",
"the",
"protection",
"attribute",
"and",
"if",
"true",
"prevents",
"the",
"store",
"from",
"being",
"cleared",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L65-L70 |
9,978 | 256dpi/gomqtt | client/future/store.go | Clear | func (s *Store) Clear() {
s.Lock()
defer s.Unlock()
if s.protected {
return
}
for _, savedFuture := range s.store {
savedFuture.Cancel()
}
s.store = make(map[packet.ID]*Future)
} | go | func (s *Store) Clear() {
s.Lock()
defer s.Unlock()
if s.protected {
return
}
for _, savedFuture := range s.store {
savedFuture.Cancel()
}
s.store = make(map[packet.ID]*Future)
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Clear",
"(",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"s",
".",
"protected",
"{",
"return",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"savedFuture",
":=",
"range",
"s",
".",
"store",
"{",
"savedFuture",
".",
"Cancel",
"(",
")",
"\n",
"}",
"\n\n",
"s",
".",
"store",
"=",
"make",
"(",
"map",
"[",
"packet",
".",
"ID",
"]",
"*",
"Future",
")",
"\n",
"}"
] | // Clear will cancel all stored futures and remove them if the store is unprotected. | [
"Clear",
"will",
"cancel",
"all",
"stored",
"futures",
"and",
"remove",
"them",
"if",
"the",
"store",
"is",
"unprotected",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L73-L86 |
9,979 | 256dpi/gomqtt | client/future/store.go | Await | func (s *Store) Await(timeout time.Duration) error {
stop := time.Now().Add(timeout)
for {
// Get futures
s.RLock()
futures := s.All()
s.RUnlock()
// return if no futures are left
if len(futures) == 0 {
return nil
}
// wait for next future to complete
err := futures[0].Wait(stop.Sub(time.Now()))
if err != nil {
return err
}
}
} | go | func (s *Store) Await(timeout time.Duration) error {
stop := time.Now().Add(timeout)
for {
// Get futures
s.RLock()
futures := s.All()
s.RUnlock()
// return if no futures are left
if len(futures) == 0 {
return nil
}
// wait for next future to complete
err := futures[0].Wait(stop.Sub(time.Now()))
if err != nil {
return err
}
}
} | [
"func",
"(",
"s",
"*",
"Store",
")",
"Await",
"(",
"timeout",
"time",
".",
"Duration",
")",
"error",
"{",
"stop",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Add",
"(",
"timeout",
")",
"\n\n",
"for",
"{",
"// Get futures",
"s",
".",
"RLock",
"(",
")",
"\n",
"futures",
":=",
"s",
".",
"All",
"(",
")",
"\n",
"s",
".",
"RUnlock",
"(",
")",
"\n\n",
"// return if no futures are left",
"if",
"len",
"(",
"futures",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// wait for next future to complete",
"err",
":=",
"futures",
"[",
"0",
"]",
".",
"Wait",
"(",
"stop",
".",
"Sub",
"(",
"time",
".",
"Now",
"(",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Await will wait until all futures have completed and removed or timeout is
// reached. | [
"Await",
"will",
"wait",
"until",
"all",
"futures",
"have",
"completed",
"and",
"removed",
"or",
"timeout",
"is",
"reached",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/future/store.go#L90-L110 |
9,980 | 256dpi/gomqtt | transport/base_conn.go | NewBaseConn | func NewBaseConn(c Carrier, maxWriteDelay time.Duration) *BaseConn {
return &BaseConn{
carrier: c,
stream: packet.NewStream(c, c, maxWriteDelay),
}
} | go | func NewBaseConn(c Carrier, maxWriteDelay time.Duration) *BaseConn {
return &BaseConn{
carrier: c,
stream: packet.NewStream(c, c, maxWriteDelay),
}
} | [
"func",
"NewBaseConn",
"(",
"c",
"Carrier",
",",
"maxWriteDelay",
"time",
".",
"Duration",
")",
"*",
"BaseConn",
"{",
"return",
"&",
"BaseConn",
"{",
"carrier",
":",
"c",
",",
"stream",
":",
"packet",
".",
"NewStream",
"(",
"c",
",",
"c",
",",
"maxWriteDelay",
")",
",",
"}",
"\n",
"}"
] | // NewBaseConn creates a new BaseConn using the specified Carrier. | [
"NewBaseConn",
"creates",
"a",
"new",
"BaseConn",
"using",
"the",
"specified",
"Carrier",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/base_conn.go#L32-L37 |
9,981 | 256dpi/gomqtt | transport/base_conn.go | Close | func (c *BaseConn) Close() error {
c.sMutex.Lock()
defer c.sMutex.Unlock()
// flush buffer
err1 := c.stream.Flush()
// close carrier
err2 := c.carrier.Close()
// handle errors
if err1 != nil {
return err1
} else if err2 != nil {
return err2
}
return nil
} | go | func (c *BaseConn) Close() error {
c.sMutex.Lock()
defer c.sMutex.Unlock()
// flush buffer
err1 := c.stream.Flush()
// close carrier
err2 := c.carrier.Close()
// handle errors
if err1 != nil {
return err1
} else if err2 != nil {
return err2
}
return nil
} | [
"func",
"(",
"c",
"*",
"BaseConn",
")",
"Close",
"(",
")",
"error",
"{",
"c",
".",
"sMutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"sMutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// flush buffer",
"err1",
":=",
"c",
".",
"stream",
".",
"Flush",
"(",
")",
"\n\n",
"// close carrier",
"err2",
":=",
"c",
".",
"carrier",
".",
"Close",
"(",
")",
"\n\n",
"// handle errors",
"if",
"err1",
"!=",
"nil",
"{",
"return",
"err1",
"\n",
"}",
"else",
"if",
"err2",
"!=",
"nil",
"{",
"return",
"err2",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close will close the underlying connection and cleanup resources. It will
// return an Error if there was an error while closing the underlying
// connection. | [
"Close",
"will",
"close",
"the",
"underlying",
"connection",
"and",
"cleanup",
"resources",
".",
"It",
"will",
"return",
"an",
"Error",
"if",
"there",
"was",
"an",
"error",
"while",
"closing",
"the",
"underlying",
"connection",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/base_conn.go#L91-L109 |
9,982 | 256dpi/gomqtt | transport/base_conn.go | SetReadLimit | func (c *BaseConn) SetReadLimit(limit int64) {
c.stream.Decoder.Limit = limit
} | go | func (c *BaseConn) SetReadLimit(limit int64) {
c.stream.Decoder.Limit = limit
} | [
"func",
"(",
"c",
"*",
"BaseConn",
")",
"SetReadLimit",
"(",
"limit",
"int64",
")",
"{",
"c",
".",
"stream",
".",
"Decoder",
".",
"Limit",
"=",
"limit",
"\n",
"}"
] | // SetReadLimit sets the maximum size of a packet that can be received.
// If the limit is greater than zero, Receive will close the connection and
// return an Error if receiving the next packet will exceed the limit. | [
"SetReadLimit",
"sets",
"the",
"maximum",
"size",
"of",
"a",
"packet",
"that",
"can",
"be",
"received",
".",
"If",
"the",
"limit",
"is",
"greater",
"than",
"zero",
"Receive",
"will",
"close",
"the",
"connection",
"and",
"return",
"an",
"Error",
"if",
"receiving",
"the",
"next",
"packet",
"will",
"exceed",
"the",
"limit",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/base_conn.go#L114-L116 |
9,983 | 256dpi/gomqtt | transport/base_conn.go | SetReadTimeout | func (c *BaseConn) SetReadTimeout(timeout time.Duration) {
c.readTimeout = timeout
// apply new timeout immediately
_ = c.resetTimeout()
} | go | func (c *BaseConn) SetReadTimeout(timeout time.Duration) {
c.readTimeout = timeout
// apply new timeout immediately
_ = c.resetTimeout()
} | [
"func",
"(",
"c",
"*",
"BaseConn",
")",
"SetReadTimeout",
"(",
"timeout",
"time",
".",
"Duration",
")",
"{",
"c",
".",
"readTimeout",
"=",
"timeout",
"\n\n",
"// apply new timeout immediately",
"_",
"=",
"c",
".",
"resetTimeout",
"(",
")",
"\n",
"}"
] | // SetReadTimeout sets the maximum time that can pass between reads.
// If no data is received in the set duration the connection will be closed
// and Read returns an error. | [
"SetReadTimeout",
"sets",
"the",
"maximum",
"time",
"that",
"can",
"pass",
"between",
"reads",
".",
"If",
"no",
"data",
"is",
"received",
"in",
"the",
"set",
"duration",
"the",
"connection",
"will",
"be",
"closed",
"and",
"Read",
"returns",
"an",
"error",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/transport/base_conn.go#L121-L126 |
9,984 | 256dpi/gomqtt | session/packet_store.go | NewPacketStoreWithPackets | func NewPacketStoreWithPackets(packets []packet.Generic) *PacketStore {
// prepare store
store := &PacketStore{
packets: make(map[packet.ID]packet.Generic),
}
// add packets
for _, pkt := range packets {
store.Save(pkt)
}
return store
} | go | func NewPacketStoreWithPackets(packets []packet.Generic) *PacketStore {
// prepare store
store := &PacketStore{
packets: make(map[packet.ID]packet.Generic),
}
// add packets
for _, pkt := range packets {
store.Save(pkt)
}
return store
} | [
"func",
"NewPacketStoreWithPackets",
"(",
"packets",
"[",
"]",
"packet",
".",
"Generic",
")",
"*",
"PacketStore",
"{",
"// prepare store",
"store",
":=",
"&",
"PacketStore",
"{",
"packets",
":",
"make",
"(",
"map",
"[",
"packet",
".",
"ID",
"]",
"packet",
".",
"Generic",
")",
",",
"}",
"\n\n",
"// add packets",
"for",
"_",
",",
"pkt",
":=",
"range",
"packets",
"{",
"store",
".",
"Save",
"(",
"pkt",
")",
"\n",
"}",
"\n\n",
"return",
"store",
"\n",
"}"
] | // NewPacketStoreWithPackets returns a new PacketStore with the provided packets. | [
"NewPacketStoreWithPackets",
"returns",
"a",
"new",
"PacketStore",
"with",
"the",
"provided",
"packets",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L23-L35 |
9,985 | 256dpi/gomqtt | session/packet_store.go | Save | func (s *PacketStore) Save(pkt packet.Generic) {
s.mutex.Lock()
defer s.mutex.Unlock()
id, ok := packet.GetID(pkt)
if ok {
s.packets[id] = pkt
}
} | go | func (s *PacketStore) Save(pkt packet.Generic) {
s.mutex.Lock()
defer s.mutex.Unlock()
id, ok := packet.GetID(pkt)
if ok {
s.packets[id] = pkt
}
} | [
"func",
"(",
"s",
"*",
"PacketStore",
")",
"Save",
"(",
"pkt",
"packet",
".",
"Generic",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"id",
",",
"ok",
":=",
"packet",
".",
"GetID",
"(",
"pkt",
")",
"\n",
"if",
"ok",
"{",
"s",
".",
"packets",
"[",
"id",
"]",
"=",
"pkt",
"\n",
"}",
"\n",
"}"
] | // Save will store a packet in the store. An eventual existing packet with the
// same id gets quietly overwritten. | [
"Save",
"will",
"store",
"a",
"packet",
"in",
"the",
"store",
".",
"An",
"eventual",
"existing",
"packet",
"with",
"the",
"same",
"id",
"gets",
"quietly",
"overwritten",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L39-L47 |
9,986 | 256dpi/gomqtt | session/packet_store.go | Lookup | func (s *PacketStore) Lookup(id packet.ID) packet.Generic {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.packets[id]
} | go | func (s *PacketStore) Lookup(id packet.ID) packet.Generic {
s.mutex.RLock()
defer s.mutex.RUnlock()
return s.packets[id]
} | [
"func",
"(",
"s",
"*",
"PacketStore",
")",
"Lookup",
"(",
"id",
"packet",
".",
"ID",
")",
"packet",
".",
"Generic",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"s",
".",
"packets",
"[",
"id",
"]",
"\n",
"}"
] | // Lookup will retrieve a packet from the store. | [
"Lookup",
"will",
"retrieve",
"a",
"packet",
"from",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L50-L55 |
9,987 | 256dpi/gomqtt | session/packet_store.go | Delete | func (s *PacketStore) Delete(id packet.ID) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.packets, id)
} | go | func (s *PacketStore) Delete(id packet.ID) {
s.mutex.Lock()
defer s.mutex.Unlock()
delete(s.packets, id)
} | [
"func",
"(",
"s",
"*",
"PacketStore",
")",
"Delete",
"(",
"id",
"packet",
".",
"ID",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"delete",
"(",
"s",
".",
"packets",
",",
"id",
")",
"\n",
"}"
] | // Delete will remove a packet from the store. | [
"Delete",
"will",
"remove",
"a",
"packet",
"from",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L58-L63 |
9,988 | 256dpi/gomqtt | session/packet_store.go | All | func (s *PacketStore) All() []packet.Generic {
s.mutex.RLock()
defer s.mutex.RUnlock()
var all []packet.Generic
for _, pkt := range s.packets {
all = append(all, pkt)
}
return all
} | go | func (s *PacketStore) All() []packet.Generic {
s.mutex.RLock()
defer s.mutex.RUnlock()
var all []packet.Generic
for _, pkt := range s.packets {
all = append(all, pkt)
}
return all
} | [
"func",
"(",
"s",
"*",
"PacketStore",
")",
"All",
"(",
")",
"[",
"]",
"packet",
".",
"Generic",
"{",
"s",
".",
"mutex",
".",
"RLock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"RUnlock",
"(",
")",
"\n\n",
"var",
"all",
"[",
"]",
"packet",
".",
"Generic",
"\n\n",
"for",
"_",
",",
"pkt",
":=",
"range",
"s",
".",
"packets",
"{",
"all",
"=",
"append",
"(",
"all",
",",
"pkt",
")",
"\n",
"}",
"\n\n",
"return",
"all",
"\n",
"}"
] | // All will return all packets currently saved in the store. | [
"All",
"will",
"return",
"all",
"packets",
"currently",
"saved",
"in",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L66-L77 |
9,989 | 256dpi/gomqtt | session/packet_store.go | Reset | func (s *PacketStore) Reset() {
s.mutex.Lock()
defer s.mutex.Unlock()
s.packets = make(map[packet.ID]packet.Generic)
} | go | func (s *PacketStore) Reset() {
s.mutex.Lock()
defer s.mutex.Unlock()
s.packets = make(map[packet.ID]packet.Generic)
} | [
"func",
"(",
"s",
"*",
"PacketStore",
")",
"Reset",
"(",
")",
"{",
"s",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"s",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"s",
".",
"packets",
"=",
"make",
"(",
"map",
"[",
"packet",
".",
"ID",
"]",
"packet",
".",
"Generic",
")",
"\n",
"}"
] | // Reset will reset the store. | [
"Reset",
"will",
"reset",
"the",
"store",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/session/packet_store.go#L80-L85 |
9,990 | 256dpi/gomqtt | client/client.go | New | func New() *Client {
return &Client{
state: clientInitialized,
Session: session.NewMemorySession(),
futureStore: future.NewStore(),
}
} | go | func New() *Client {
return &Client{
state: clientInitialized,
Session: session.NewMemorySession(),
futureStore: future.NewStore(),
}
} | [
"func",
"New",
"(",
")",
"*",
"Client",
"{",
"return",
"&",
"Client",
"{",
"state",
":",
"clientInitialized",
",",
"Session",
":",
"session",
".",
"NewMemorySession",
"(",
")",
",",
"futureStore",
":",
"future",
".",
"NewStore",
"(",
")",
",",
"}",
"\n",
"}"
] | // New returns a new client that by default uses a fresh MemorySession. | [
"New",
"returns",
"a",
"new",
"client",
"that",
"by",
"default",
"uses",
"a",
"fresh",
"MemorySession",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L135-L141 |
9,991 | 256dpi/gomqtt | client/client.go | Connect | func (c *Client) Connect(config *Config) (ConnectFuture, error) {
if config == nil {
panic("no config specified")
}
c.mutex.Lock()
defer c.mutex.Unlock()
// check if already connecting
if atomic.LoadUint32(&c.state) >= clientConnecting {
return nil, ErrClientAlreadyConnecting
}
// save config
c.config = config
// parse url
urlParts, err := url.ParseRequestURI(config.BrokerURL)
if err != nil {
return nil, err
}
// check client id
if !config.CleanSession && config.ClientID == "" {
return nil, ErrClientMissingID
}
// parse keep alive
keepAlive, err := time.ParseDuration(config.KeepAlive)
if err != nil {
return nil, err
}
// allocate and initialize tracker
c.keepAlive = keepAlive
c.tracker = NewTracker(keepAlive)
// dial broker (with custom dialer if present)
if config.Dialer != nil {
c.conn, err = config.Dialer.Dial(config.BrokerURL)
if err != nil {
return nil, err
}
} else {
c.conn, err = transport.Dial(config.BrokerURL)
if err != nil {
return nil, err
}
}
// set to connecting as from this point the client cannot be reused
atomic.StoreUint32(&c.state, clientConnecting)
// from now on the connection has been used and we have to close the
// connection and cleanup on any subsequent error
// save clean
c.clean = config.CleanSession
// reset store
if c.clean {
err = c.Session.Reset()
if err != nil {
return nil, c.cleanup(err, true, false)
}
}
// allocate packet
connect := packet.NewConnect()
connect.ClientID = config.ClientID
connect.KeepAlive = uint16(keepAlive.Seconds())
connect.CleanSession = config.CleanSession
// check for credentials
if urlParts.User != nil {
connect.Username = urlParts.User.Username()
connect.Password, _ = urlParts.User.Password()
}
// set will
connect.Will = config.WillMessage
// create new ConnectFuture
c.connectFuture = future.New()
// send connect packet
err = c.send(connect, false)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// start process routine
c.tomb.Go(c.processor)
// wrap future
wrappedFuture := &connectFuture{c.connectFuture}
return wrappedFuture, nil
} | go | func (c *Client) Connect(config *Config) (ConnectFuture, error) {
if config == nil {
panic("no config specified")
}
c.mutex.Lock()
defer c.mutex.Unlock()
// check if already connecting
if atomic.LoadUint32(&c.state) >= clientConnecting {
return nil, ErrClientAlreadyConnecting
}
// save config
c.config = config
// parse url
urlParts, err := url.ParseRequestURI(config.BrokerURL)
if err != nil {
return nil, err
}
// check client id
if !config.CleanSession && config.ClientID == "" {
return nil, ErrClientMissingID
}
// parse keep alive
keepAlive, err := time.ParseDuration(config.KeepAlive)
if err != nil {
return nil, err
}
// allocate and initialize tracker
c.keepAlive = keepAlive
c.tracker = NewTracker(keepAlive)
// dial broker (with custom dialer if present)
if config.Dialer != nil {
c.conn, err = config.Dialer.Dial(config.BrokerURL)
if err != nil {
return nil, err
}
} else {
c.conn, err = transport.Dial(config.BrokerURL)
if err != nil {
return nil, err
}
}
// set to connecting as from this point the client cannot be reused
atomic.StoreUint32(&c.state, clientConnecting)
// from now on the connection has been used and we have to close the
// connection and cleanup on any subsequent error
// save clean
c.clean = config.CleanSession
// reset store
if c.clean {
err = c.Session.Reset()
if err != nil {
return nil, c.cleanup(err, true, false)
}
}
// allocate packet
connect := packet.NewConnect()
connect.ClientID = config.ClientID
connect.KeepAlive = uint16(keepAlive.Seconds())
connect.CleanSession = config.CleanSession
// check for credentials
if urlParts.User != nil {
connect.Username = urlParts.User.Username()
connect.Password, _ = urlParts.User.Password()
}
// set will
connect.Will = config.WillMessage
// create new ConnectFuture
c.connectFuture = future.New()
// send connect packet
err = c.send(connect, false)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// start process routine
c.tomb.Go(c.processor)
// wrap future
wrappedFuture := &connectFuture{c.connectFuture}
return wrappedFuture, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Connect",
"(",
"config",
"*",
"Config",
")",
"(",
"ConnectFuture",
",",
"error",
")",
"{",
"if",
"config",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if already connecting",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
">=",
"clientConnecting",
"{",
"return",
"nil",
",",
"ErrClientAlreadyConnecting",
"\n",
"}",
"\n\n",
"// save config",
"c",
".",
"config",
"=",
"config",
"\n\n",
"// parse url",
"urlParts",
",",
"err",
":=",
"url",
".",
"ParseRequestURI",
"(",
"config",
".",
"BrokerURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// check client id",
"if",
"!",
"config",
".",
"CleanSession",
"&&",
"config",
".",
"ClientID",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"ErrClientMissingID",
"\n",
"}",
"\n\n",
"// parse keep alive",
"keepAlive",
",",
"err",
":=",
"time",
".",
"ParseDuration",
"(",
"config",
".",
"KeepAlive",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// allocate and initialize tracker",
"c",
".",
"keepAlive",
"=",
"keepAlive",
"\n",
"c",
".",
"tracker",
"=",
"NewTracker",
"(",
"keepAlive",
")",
"\n\n",
"// dial broker (with custom dialer if present)",
"if",
"config",
".",
"Dialer",
"!=",
"nil",
"{",
"c",
".",
"conn",
",",
"err",
"=",
"config",
".",
"Dialer",
".",
"Dial",
"(",
"config",
".",
"BrokerURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"c",
".",
"conn",
",",
"err",
"=",
"transport",
".",
"Dial",
"(",
"config",
".",
"BrokerURL",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"// set to connecting as from this point the client cannot be reused",
"atomic",
".",
"StoreUint32",
"(",
"&",
"c",
".",
"state",
",",
"clientConnecting",
")",
"\n\n",
"// from now on the connection has been used and we have to close the",
"// connection and cleanup on any subsequent error",
"// save clean",
"c",
".",
"clean",
"=",
"config",
".",
"CleanSession",
"\n\n",
"// reset store",
"if",
"c",
".",
"clean",
"{",
"err",
"=",
"c",
".",
"Session",
".",
"Reset",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// allocate packet",
"connect",
":=",
"packet",
".",
"NewConnect",
"(",
")",
"\n",
"connect",
".",
"ClientID",
"=",
"config",
".",
"ClientID",
"\n",
"connect",
".",
"KeepAlive",
"=",
"uint16",
"(",
"keepAlive",
".",
"Seconds",
"(",
")",
")",
"\n",
"connect",
".",
"CleanSession",
"=",
"config",
".",
"CleanSession",
"\n\n",
"// check for credentials",
"if",
"urlParts",
".",
"User",
"!=",
"nil",
"{",
"connect",
".",
"Username",
"=",
"urlParts",
".",
"User",
".",
"Username",
"(",
")",
"\n",
"connect",
".",
"Password",
",",
"_",
"=",
"urlParts",
".",
"User",
".",
"Password",
"(",
")",
"\n",
"}",
"\n\n",
"// set will",
"connect",
".",
"Will",
"=",
"config",
".",
"WillMessage",
"\n\n",
"// create new ConnectFuture",
"c",
".",
"connectFuture",
"=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// send connect packet",
"err",
"=",
"c",
".",
"send",
"(",
"connect",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// start process routine",
"c",
".",
"tomb",
".",
"Go",
"(",
"c",
".",
"processor",
")",
"\n\n",
"// wrap future",
"wrappedFuture",
":=",
"&",
"connectFuture",
"{",
"c",
".",
"connectFuture",
"}",
"\n\n",
"return",
"wrappedFuture",
",",
"nil",
"\n",
"}"
] | // Connect opens the connection to the broker and sends a Connect packet. It will
// return a ConnectFuture that gets completed once a Connack has been
// received. If the Connect packet couldn't be transmitted it will return an error. | [
"Connect",
"opens",
"the",
"connection",
"to",
"the",
"broker",
"and",
"sends",
"a",
"Connect",
"packet",
".",
"It",
"will",
"return",
"a",
"ConnectFuture",
"that",
"gets",
"completed",
"once",
"a",
"Connack",
"has",
"been",
"received",
".",
"If",
"the",
"Connect",
"packet",
"couldn",
"t",
"be",
"transmitted",
"it",
"will",
"return",
"an",
"error",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L146-L244 |
9,992 | 256dpi/gomqtt | client/client.go | PublishMessage | func (c *Client) PublishMessage(msg *packet.Message) (GenericFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate publish packet
publish := packet.NewPublish()
publish.Message = *msg
// set packet id
if msg.QOS > 0 {
publish.ID = c.Session.NextID()
}
// create future
publishFuture := future.New()
// store future
c.futureStore.Put(publish.ID, publishFuture)
// store packet if at least qos 1
if msg.QOS > 0 {
err := c.Session.SavePacket(session.Outgoing, publish)
if err != nil {
return nil, c.cleanup(err, true, false)
}
}
// send packet
err := c.send(publish, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// complete and remove qos 0 future
if msg.QOS == 0 {
publishFuture.Complete()
c.futureStore.Delete(publish.ID)
}
return publishFuture, nil
} | go | func (c *Client) PublishMessage(msg *packet.Message) (GenericFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate publish packet
publish := packet.NewPublish()
publish.Message = *msg
// set packet id
if msg.QOS > 0 {
publish.ID = c.Session.NextID()
}
// create future
publishFuture := future.New()
// store future
c.futureStore.Put(publish.ID, publishFuture)
// store packet if at least qos 1
if msg.QOS > 0 {
err := c.Session.SavePacket(session.Outgoing, publish)
if err != nil {
return nil, c.cleanup(err, true, false)
}
}
// send packet
err := c.send(publish, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// complete and remove qos 0 future
if msg.QOS == 0 {
publishFuture.Complete()
c.futureStore.Delete(publish.ID)
}
return publishFuture, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"PublishMessage",
"(",
"msg",
"*",
"packet",
".",
"Message",
")",
"(",
"GenericFuture",
",",
"error",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if connected",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"!=",
"clientConnected",
"{",
"return",
"nil",
",",
"ErrClientNotConnected",
"\n",
"}",
"\n\n",
"// allocate publish packet",
"publish",
":=",
"packet",
".",
"NewPublish",
"(",
")",
"\n",
"publish",
".",
"Message",
"=",
"*",
"msg",
"\n\n",
"// set packet id",
"if",
"msg",
".",
"QOS",
">",
"0",
"{",
"publish",
".",
"ID",
"=",
"c",
".",
"Session",
".",
"NextID",
"(",
")",
"\n",
"}",
"\n\n",
"// create future",
"publishFuture",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// store future",
"c",
".",
"futureStore",
".",
"Put",
"(",
"publish",
".",
"ID",
",",
"publishFuture",
")",
"\n\n",
"// store packet if at least qos 1",
"if",
"msg",
".",
"QOS",
">",
"0",
"{",
"err",
":=",
"c",
".",
"Session",
".",
"SavePacket",
"(",
"session",
".",
"Outgoing",
",",
"publish",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// send packet",
"err",
":=",
"c",
".",
"send",
"(",
"publish",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// complete and remove qos 0 future",
"if",
"msg",
".",
"QOS",
"==",
"0",
"{",
"publishFuture",
".",
"Complete",
"(",
")",
"\n",
"c",
".",
"futureStore",
".",
"Delete",
"(",
"publish",
".",
"ID",
")",
"\n",
"}",
"\n\n",
"return",
"publishFuture",
",",
"nil",
"\n",
"}"
] | // PublishMessage will send a Publish containing the passed message. It will
// return a PublishFuture that gets completed once the quality of service flow
// has been completed. | [
"PublishMessage",
"will",
"send",
"a",
"Publish",
"containing",
"the",
"passed",
"message",
".",
"It",
"will",
"return",
"a",
"PublishFuture",
"that",
"gets",
"completed",
"once",
"the",
"quality",
"of",
"service",
"flow",
"has",
"been",
"completed",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L263-L308 |
9,993 | 256dpi/gomqtt | client/client.go | Subscribe | func (c *Client) Subscribe(topic string, qos packet.QOS) (SubscribeFuture, error) {
return c.SubscribeMultiple([]packet.Subscription{
{Topic: topic, QOS: qos},
})
} | go | func (c *Client) Subscribe(topic string, qos packet.QOS) (SubscribeFuture, error) {
return c.SubscribeMultiple([]packet.Subscription{
{Topic: topic, QOS: qos},
})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Subscribe",
"(",
"topic",
"string",
",",
"qos",
"packet",
".",
"QOS",
")",
"(",
"SubscribeFuture",
",",
"error",
")",
"{",
"return",
"c",
".",
"SubscribeMultiple",
"(",
"[",
"]",
"packet",
".",
"Subscription",
"{",
"{",
"Topic",
":",
"topic",
",",
"QOS",
":",
"qos",
"}",
",",
"}",
")",
"\n",
"}"
] | // Subscribe will send a Subscribe packet containing one topic to subscribe. It
// will return a SubscribeFuture that gets completed once a Suback packet has
// been received. | [
"Subscribe",
"will",
"send",
"a",
"Subscribe",
"packet",
"containing",
"one",
"topic",
"to",
"subscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"a",
"Suback",
"packet",
"has",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L313-L317 |
9,994 | 256dpi/gomqtt | client/client.go | SubscribeMultiple | func (c *Client) SubscribeMultiple(subscriptions []packet.Subscription) (SubscribeFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate subscribe packet
subscribe := packet.NewSubscribe()
subscribe.ID = c.Session.NextID()
subscribe.Subscriptions = subscriptions
// create future
subFuture := future.New()
// store future
c.futureStore.Put(subscribe.ID, subFuture)
// send packet
err := c.send(subscribe, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// wrap future
wrappedFuture := &subscribeFuture{subFuture}
return wrappedFuture, nil
} | go | func (c *Client) SubscribeMultiple(subscriptions []packet.Subscription) (SubscribeFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate subscribe packet
subscribe := packet.NewSubscribe()
subscribe.ID = c.Session.NextID()
subscribe.Subscriptions = subscriptions
// create future
subFuture := future.New()
// store future
c.futureStore.Put(subscribe.ID, subFuture)
// send packet
err := c.send(subscribe, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
// wrap future
wrappedFuture := &subscribeFuture{subFuture}
return wrappedFuture, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SubscribeMultiple",
"(",
"subscriptions",
"[",
"]",
"packet",
".",
"Subscription",
")",
"(",
"SubscribeFuture",
",",
"error",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if connected",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"!=",
"clientConnected",
"{",
"return",
"nil",
",",
"ErrClientNotConnected",
"\n",
"}",
"\n\n",
"// allocate subscribe packet",
"subscribe",
":=",
"packet",
".",
"NewSubscribe",
"(",
")",
"\n",
"subscribe",
".",
"ID",
"=",
"c",
".",
"Session",
".",
"NextID",
"(",
")",
"\n",
"subscribe",
".",
"Subscriptions",
"=",
"subscriptions",
"\n\n",
"// create future",
"subFuture",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// store future",
"c",
".",
"futureStore",
".",
"Put",
"(",
"subscribe",
".",
"ID",
",",
"subFuture",
")",
"\n\n",
"// send packet",
"err",
":=",
"c",
".",
"send",
"(",
"subscribe",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// wrap future",
"wrappedFuture",
":=",
"&",
"subscribeFuture",
"{",
"subFuture",
"}",
"\n\n",
"return",
"wrappedFuture",
",",
"nil",
"\n",
"}"
] | // SubscribeMultiple will send a Subscribe packet containing multiple topics to
// subscribe. It will return a SubscribeFuture that gets completed once a
// Suback packet has been received. | [
"SubscribeMultiple",
"will",
"send",
"a",
"Subscribe",
"packet",
"containing",
"multiple",
"topics",
"to",
"subscribe",
".",
"It",
"will",
"return",
"a",
"SubscribeFuture",
"that",
"gets",
"completed",
"once",
"a",
"Suback",
"packet",
"has",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L322-L352 |
9,995 | 256dpi/gomqtt | client/client.go | Unsubscribe | func (c *Client) Unsubscribe(topic string) (GenericFuture, error) {
return c.UnsubscribeMultiple([]string{topic})
} | go | func (c *Client) Unsubscribe(topic string) (GenericFuture, error) {
return c.UnsubscribeMultiple([]string{topic})
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Unsubscribe",
"(",
"topic",
"string",
")",
"(",
"GenericFuture",
",",
"error",
")",
"{",
"return",
"c",
".",
"UnsubscribeMultiple",
"(",
"[",
"]",
"string",
"{",
"topic",
"}",
")",
"\n",
"}"
] | // Unsubscribe will send a Unsubscribe packet containing one topic to unsubscribe.
// It will return a UnsubscribeFuture that gets completed once an Unsuback packet
// has been received. | [
"Unsubscribe",
"will",
"send",
"a",
"Unsubscribe",
"packet",
"containing",
"one",
"topic",
"to",
"unsubscribe",
".",
"It",
"will",
"return",
"a",
"UnsubscribeFuture",
"that",
"gets",
"completed",
"once",
"an",
"Unsuback",
"packet",
"has",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L357-L359 |
9,996 | 256dpi/gomqtt | client/client.go | UnsubscribeMultiple | func (c *Client) UnsubscribeMultiple(topics []string) (GenericFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate unsubscribe packet
unsubscribe := packet.NewUnsubscribe()
unsubscribe.Topics = topics
unsubscribe.ID = c.Session.NextID()
// create future
unsubscribeFuture := future.New()
// store future
c.futureStore.Put(unsubscribe.ID, unsubscribeFuture)
// send packet
err := c.send(unsubscribe, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
return unsubscribeFuture, nil
} | go | func (c *Client) UnsubscribeMultiple(topics []string) (GenericFuture, error) {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return nil, ErrClientNotConnected
}
// allocate unsubscribe packet
unsubscribe := packet.NewUnsubscribe()
unsubscribe.Topics = topics
unsubscribe.ID = c.Session.NextID()
// create future
unsubscribeFuture := future.New()
// store future
c.futureStore.Put(unsubscribe.ID, unsubscribeFuture)
// send packet
err := c.send(unsubscribe, true)
if err != nil {
return nil, c.cleanup(err, false, false)
}
return unsubscribeFuture, nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UnsubscribeMultiple",
"(",
"topics",
"[",
"]",
"string",
")",
"(",
"GenericFuture",
",",
"error",
")",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if connected",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"!=",
"clientConnected",
"{",
"return",
"nil",
",",
"ErrClientNotConnected",
"\n",
"}",
"\n\n",
"// allocate unsubscribe packet",
"unsubscribe",
":=",
"packet",
".",
"NewUnsubscribe",
"(",
")",
"\n",
"unsubscribe",
".",
"Topics",
"=",
"topics",
"\n",
"unsubscribe",
".",
"ID",
"=",
"c",
".",
"Session",
".",
"NextID",
"(",
")",
"\n\n",
"// create future",
"unsubscribeFuture",
":=",
"future",
".",
"New",
"(",
")",
"\n\n",
"// store future",
"c",
".",
"futureStore",
".",
"Put",
"(",
"unsubscribe",
".",
"ID",
",",
"unsubscribeFuture",
")",
"\n\n",
"// send packet",
"err",
":=",
"c",
".",
"send",
"(",
"unsubscribe",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"c",
".",
"cleanup",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n\n",
"return",
"unsubscribeFuture",
",",
"nil",
"\n",
"}"
] | // UnsubscribeMultiple will send a Unsubscribe packet containing multiple
// topics to unsubscribe. It will return a UnsubscribeFuture that gets completed
// once an Unsuback packet has been received. | [
"UnsubscribeMultiple",
"will",
"send",
"a",
"Unsubscribe",
"packet",
"containing",
"multiple",
"topics",
"to",
"unsubscribe",
".",
"It",
"will",
"return",
"a",
"UnsubscribeFuture",
"that",
"gets",
"completed",
"once",
"an",
"Unsuback",
"packet",
"has",
"been",
"received",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L364-L391 |
9,997 | 256dpi/gomqtt | client/client.go | Disconnect | func (c *Client) Disconnect(timeout ...time.Duration) error {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return ErrClientNotConnected
}
// finish current packets
if len(timeout) > 0 {
c.futureStore.Await(timeout[0])
}
// set state
atomic.StoreUint32(&c.state, clientDisconnecting)
// send disconnect packet
err := c.send(packet.NewDisconnect(), false)
return c.end(err, true)
} | go | func (c *Client) Disconnect(timeout ...time.Duration) error {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) != clientConnected {
return ErrClientNotConnected
}
// finish current packets
if len(timeout) > 0 {
c.futureStore.Await(timeout[0])
}
// set state
atomic.StoreUint32(&c.state, clientDisconnecting)
// send disconnect packet
err := c.send(packet.NewDisconnect(), false)
return c.end(err, true)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Disconnect",
"(",
"timeout",
"...",
"time",
".",
"Duration",
")",
"error",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if connected",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"!=",
"clientConnected",
"{",
"return",
"ErrClientNotConnected",
"\n",
"}",
"\n\n",
"// finish current packets",
"if",
"len",
"(",
"timeout",
")",
">",
"0",
"{",
"c",
".",
"futureStore",
".",
"Await",
"(",
"timeout",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"// set state",
"atomic",
".",
"StoreUint32",
"(",
"&",
"c",
".",
"state",
",",
"clientDisconnecting",
")",
"\n\n",
"// send disconnect packet",
"err",
":=",
"c",
".",
"send",
"(",
"packet",
".",
"NewDisconnect",
"(",
")",
",",
"false",
")",
"\n\n",
"return",
"c",
".",
"end",
"(",
"err",
",",
"true",
")",
"\n",
"}"
] | // Disconnect will send a Disconnect packet and close the connection.
//
// If a timeout is specified, the client will wait the specified amount of time
// for all queued futures to complete or cancel. If no timeout is specified it
// will not wait at all. | [
"Disconnect",
"will",
"send",
"a",
"Disconnect",
"packet",
"and",
"close",
"the",
"connection",
".",
"If",
"a",
"timeout",
"is",
"specified",
"the",
"client",
"will",
"wait",
"the",
"specified",
"amount",
"of",
"time",
"for",
"all",
"queued",
"futures",
"to",
"complete",
"or",
"cancel",
".",
"If",
"no",
"timeout",
"is",
"specified",
"it",
"will",
"not",
"wait",
"at",
"all",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L398-L419 |
9,998 | 256dpi/gomqtt | client/client.go | Close | func (c *Client) Close() error {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) < clientConnecting {
return ErrClientNotConnected
}
return c.end(nil, false)
} | go | func (c *Client) Close() error {
c.mutex.Lock()
defer c.mutex.Unlock()
// check if connected
if atomic.LoadUint32(&c.state) < clientConnecting {
return ErrClientNotConnected
}
return c.end(nil, false)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Close",
"(",
")",
"error",
"{",
"c",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n\n",
"// check if connected",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"<",
"clientConnecting",
"{",
"return",
"ErrClientNotConnected",
"\n",
"}",
"\n\n",
"return",
"c",
".",
"end",
"(",
"nil",
",",
"false",
")",
"\n",
"}"
] | // Close closes the client immediately without sending a Disconnect packet and
// waiting for outgoing transmissions to finish. | [
"Close",
"closes",
"the",
"client",
"immediately",
"without",
"sending",
"a",
"Disconnect",
"packet",
"and",
"waiting",
"for",
"outgoing",
"transmissions",
"to",
"finish",
"."
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L423-L433 |
9,999 | 256dpi/gomqtt | client/client.go | processConnack | func (c *Client) processConnack(connack *packet.Connack) error {
// check state
if atomic.LoadUint32(&c.state) != clientConnecting {
return nil // ignore wrongly sent Connack packet
}
// set state
atomic.StoreUint32(&c.state, clientConnacked)
// fill future
c.connectFuture.Data.Store(sessionPresentKey, connack.SessionPresent)
c.connectFuture.Data.Store(returnCodeKey, connack.ReturnCode)
// return connection denied error and close connection if not accepted
if connack.ReturnCode != packet.ConnectionAccepted {
err := c.die(ErrClientConnectionDenied, true, false)
c.connectFuture.Cancel()
return err
}
// set state to connected
atomic.StoreUint32(&c.state, clientConnected)
// complete future
c.connectFuture.Complete()
// retrieve stored packets
packets, err := c.Session.AllPackets(session.Outgoing)
if err != nil {
return c.die(err, true, false)
}
// resend stored packets
for _, pkt := range packets {
// check for publish packets
publish, ok := pkt.(*packet.Publish)
if ok {
// set the dup flag on a publish packet
publish.Dup = true
}
// resend packet
err = c.send(pkt, true)
if err != nil {
return c.die(err, false, false)
}
}
return nil
} | go | func (c *Client) processConnack(connack *packet.Connack) error {
// check state
if atomic.LoadUint32(&c.state) != clientConnecting {
return nil // ignore wrongly sent Connack packet
}
// set state
atomic.StoreUint32(&c.state, clientConnacked)
// fill future
c.connectFuture.Data.Store(sessionPresentKey, connack.SessionPresent)
c.connectFuture.Data.Store(returnCodeKey, connack.ReturnCode)
// return connection denied error and close connection if not accepted
if connack.ReturnCode != packet.ConnectionAccepted {
err := c.die(ErrClientConnectionDenied, true, false)
c.connectFuture.Cancel()
return err
}
// set state to connected
atomic.StoreUint32(&c.state, clientConnected)
// complete future
c.connectFuture.Complete()
// retrieve stored packets
packets, err := c.Session.AllPackets(session.Outgoing)
if err != nil {
return c.die(err, true, false)
}
// resend stored packets
for _, pkt := range packets {
// check for publish packets
publish, ok := pkt.(*packet.Publish)
if ok {
// set the dup flag on a publish packet
publish.Dup = true
}
// resend packet
err = c.send(pkt, true)
if err != nil {
return c.die(err, false, false)
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"processConnack",
"(",
"connack",
"*",
"packet",
".",
"Connack",
")",
"error",
"{",
"// check state",
"if",
"atomic",
".",
"LoadUint32",
"(",
"&",
"c",
".",
"state",
")",
"!=",
"clientConnecting",
"{",
"return",
"nil",
"// ignore wrongly sent Connack packet",
"\n",
"}",
"\n\n",
"// set state",
"atomic",
".",
"StoreUint32",
"(",
"&",
"c",
".",
"state",
",",
"clientConnacked",
")",
"\n\n",
"// fill future",
"c",
".",
"connectFuture",
".",
"Data",
".",
"Store",
"(",
"sessionPresentKey",
",",
"connack",
".",
"SessionPresent",
")",
"\n",
"c",
".",
"connectFuture",
".",
"Data",
".",
"Store",
"(",
"returnCodeKey",
",",
"connack",
".",
"ReturnCode",
")",
"\n\n",
"// return connection denied error and close connection if not accepted",
"if",
"connack",
".",
"ReturnCode",
"!=",
"packet",
".",
"ConnectionAccepted",
"{",
"err",
":=",
"c",
".",
"die",
"(",
"ErrClientConnectionDenied",
",",
"true",
",",
"false",
")",
"\n",
"c",
".",
"connectFuture",
".",
"Cancel",
"(",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// set state to connected",
"atomic",
".",
"StoreUint32",
"(",
"&",
"c",
".",
"state",
",",
"clientConnected",
")",
"\n\n",
"// complete future",
"c",
".",
"connectFuture",
".",
"Complete",
"(",
")",
"\n\n",
"// retrieve stored packets",
"packets",
",",
"err",
":=",
"c",
".",
"Session",
".",
"AllPackets",
"(",
"session",
".",
"Outgoing",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"true",
",",
"false",
")",
"\n",
"}",
"\n\n",
"// resend stored packets",
"for",
"_",
",",
"pkt",
":=",
"range",
"packets",
"{",
"// check for publish packets",
"publish",
",",
"ok",
":=",
"pkt",
".",
"(",
"*",
"packet",
".",
"Publish",
")",
"\n",
"if",
"ok",
"{",
"// set the dup flag on a publish packet",
"publish",
".",
"Dup",
"=",
"true",
"\n",
"}",
"\n\n",
"// resend packet",
"err",
"=",
"c",
".",
"send",
"(",
"pkt",
",",
"true",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
".",
"die",
"(",
"err",
",",
"false",
",",
"false",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // handle the incoming Connack packet | [
"handle",
"the",
"incoming",
"Connack",
"packet"
] | 84c68b46ee22292c5ac9c44c7678ac33ae14f130 | https://github.com/256dpi/gomqtt/blob/84c68b46ee22292c5ac9c44c7678ac33ae14f130/client/client.go#L507-L556 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.