MCPcopy Create free account

hub / github.com/siddontang/go / functions

Functions607 in github.com/siddontang/go

⨍ Functions 607◇ Types & classes 121
↓ 3 callersFunctionInfof
(format string, v ...interface{})
log/log.go:329
↓ 3 callersMethodInsertAfter
(v interface{}, mark *Element)
list2/list.go:200
↓ 3 callersMethodMPop
(n int)
ring/ring.go:49
↓ 3 callersMethodMake
(size int)
arena/arena.go:18
↓ 3 callersMethodMakeRpc
(rpcName string, fptr interface{})
rpc/client.go:54
↓ 3 callersMethodPing
(message []byte)
websocket/conn.go:113
↓ 3 callersMethodPong
(message []byte)
websocket/conn.go:117
↓ 3 callersMethodRelease
()
sync2/semaphore.go:23
↓ 3 callersMethodSetBool
(key string, v bool)
config/config.go:157
↓ 3 callersMethodWrite
(p []byte)
log/filehandler.go:81
↓ 3 callersMethodaddBinary
-------------------------------------------------------------------------- Marshaling of base types.
bson/encode.go:426
↓ 3 callersMethodaddCStr
(v string)
bson/encode.go:444
↓ 3 callersMethodcheckCapacity
()
cache/lru_cache.go:244
↓ 3 callersMethoddelTimer
(t *timer)
time2/wheel.go:179
↓ 3 callersFunctionemitLiteral
emitLiteral writes a literal chunk and returns the number of bytes written.
snappy/encode.go:15
↓ 3 callersFunctionhandleErr
(err *error)
bson/bson.go:391
↓ 3 callersMethodmoveToFront
(element *list.Element)
cache/lru_cache.go:231
↓ 3 callersFunctionnewTestClient
()
rpc/rpc_test.go:26
↓ 3 callersFunctionnewTestServer
()
rpc/rpc_test.go:15
↓ 3 callersFunctiontestConfig
(cfg *Config, t *testing.T)
config/config_test.go:9
↓ 3 callersFunctiontestCrossPair
(c *C, dump interface{}, load interface{})
bson/bson_test.go:1262
↓ 3 callersFunctiontestUnmarshal
(c *C, data string, obj interface{})
bson/bson_test.go:78
↓ 2 callersMethodAcquireTimeout
(timeout time.Duration)
sync2/semaphore.go:41
↓ 2 callersMethodCall
(data []byte)
rpc/conn.go:29
↓ 2 callersMethodCompareAndSwap
(oldval, newval string)
sync2/atomic.go:124
↓ 2 callersFunctionDecode
Decode returns the decoded form of src. The returned slice may be a sub- slice of dst if dst was large enough to hold the entire decoded block. Otherw
snappy/decode.go:38
↓ 2 callersMethodDelete
Delete removes an entry from the cache, and returns if the entry existed.
cache/lru_cache.go:107
↓ 2 callersMethodEmpty
()
ring/ring.go:99
↓ 2 callersMethodGetBSON
()
bson/bson.go:62
↓ 2 callersMethodGetInt64
* int may be pure number or below format: # 1k => 1000 bytes # 1kb => 1024 bytes # 1m => 1000000 bytes # 1mb => 1024*1
config/config.go:62
↓ 2 callersMethodGetString
(key string)
config/config.go:132
↓ 2 callersMethodGets
(n int)
ring/ring.go:103
↓ 2 callersMethodInfo
log with info level
log/log.go:235
↓ 2 callersFunctionMaxEncodedLen
MaxEncodedLen returns the maximum length of a snappy block, given its uncompressed length.
snappy/encode.go:152
↓ 2 callersFunctionNewClient
(netConn net.Conn, u *url.URL, requestHeader http.Header)
websocket/client.go:16
↓ 2 callersFunctionNewConfig
()
config/config.go:25
↓ 2 callersFunctionNewConn
(conn net.Conn, isServer bool)
websocket/conn.go:40
↓ 2 callersFunctionNewDefault
new a default logger with specified handler and flag: Ltime|Lfile|Llevel
log/log.go:76
↓ 2 callersFunctionNewRing
(maxSize int)
ring/ring.go:20
↓ 2 callersFunctionNewSectionWriter
(w io.WriterAt, off int64, n int64)
ioutil2/sectionwriter.go:10
↓ 2 callersFunctionNewSemaphore
(initialCount int)
sync2/semaphore.go:9
↓ 2 callersFunctionNewSize
(size int)
list2/list.go:47
↓ 2 callersFunctionNewStreamHandler
(w io.Writer)
log/handler.go:18
↓ 2 callersFunctionNewWheel
tick is the time for a jiffies
time2/wheel.go:52
↓ 2 callersMethodRead
(r io.Reader)
config/read.go:32
↓ 2 callersFunctionReadConfig
(data []byte)
config/read.go:22
↓ 2 callersMethodReadMessage
()
rpc/conn.go:59
↓ 2 callersFunctionRegisterType
(value interface{})
rpc/codec.go:17
↓ 2 callersMethodReset
()
bytes2/chunked_writer.go:51
↓ 2 callersMethodSet
(v bool)
sync2/atomic.go:136
↓ 2 callersMethodSetBSON
(raw Raw)
bson/bson.go:93
↓ 2 callersMethodSetIfAbsent
SetIfAbsent will set the value in the cache if not present. If the value exists in the cache, we don't set it.
cache/lru_cache.go:95
↓ 2 callersMethodStart
()
rpc/server.go:33
↓ 2 callersMethodStatsJSON
StatsJSON returns stats as a JSON object in a string.
cache/lru_cache.go:154
↓ 2 callersMethodTickFunc
(d time.Duration, f func())
time2/wheel.go:260
↓ 2 callersFunctionUpgrade
(w http.ResponseWriter, r *http.Request, responseHeader http.Header)
websocket/server.go:22
↓ 2 callersMethodWrite
(message []byte, binary bool)
websocket/conn.go:91
↓ 2 callersMethodWriteMessage
(data []byte)
rpc/conn.go:41
↓ 2 callersMethodaddFloat64
(v float64)
bson/encode.go:473
↓ 2 callersMethodaddNew
(key string, value Value)
cache/lru_cache.go:236
↓ 2 callersMethodaddTimerInternal
(t *timer)
time2/wheel.go:79
↓ 2 callersFunctionbenchDecode
(b *testing.B, src []byte)
snappy/snappy_test.go:82
↓ 2 callersFunctionbenchEncode
(b *testing.B, src []byte)
snappy/snappy_test.go:95
↓ 2 callersFunctioncalcAcceptKey
(key string)
websocket/util.go:13
↓ 2 callersFunctioncheckListLen
(t *testing.T, l *List, len int)
list2/list_test.go:8
↓ 2 callersFunctionclearMap
(m reflect.Value)
bson/decode.go:117
↓ 2 callersFunctiondecodeData
(data []byte)
rpc/codec.go:48
↓ 2 callersFunctiondecodedLen
decodedLen returns the length of the decoded block and the number of bytes that the length header occupied.
snappy/decode.go:23
↓ 2 callersMethoddropElem
(kind byte)
bson/decode.go:425
↓ 2 callersFunctionencodeData
(name string, args []interface{})
rpc/codec.go:32
↓ 2 callersFunctiongetSetter
(outt reflect.Type, out reflect.Value)
bson/decode.go:86
↓ 2 callersFunctiongetStructInfo
(st reflect.Type)
bson/bson.go:560
↓ 2 callersMethodmaskingData
(data []byte, maskingKey []byte)
websocket/conn.go:312
↓ 2 callersFunctionnewDecoder
(in []byte)
bson/decode.go:48
↓ 2 callersFunctionparseURL
(s string)
bson/bson_test.go:1046
↓ 2 callersMethodreadDocElems
(typ reflect.Type)
bson/decode.go:363
↓ 2 callersMethodreadDocWith
(f func(kind byte, name string))
bson/decode.go:397
↓ 2 callersFunctionreadFile
(b *testing.B, filename string)
snappy/snappy_test.go:105
↓ 2 callersMethodreadRawDocElems
(typ reflect.Type)
bson/decode.go:380
↓ 2 callersMethodreadSliceDoc
(t reflect.Type)
bson/decode.go:321
↓ 2 callersMethodreserveInt32
()
bson/encode.go:449
↓ 2 callersMethodresetTimer
(t *timer, when time.Duration, period time.Duration)
time2/wheel.go:191
↓ 2 callersMethodsetInt32
(pos int, v int32)
bson/encode.go:455
↓ 2 callersFunctionspawn
(prog, filename string)
filelock/file_lock_test.go:17
↓ 1 callersMethodAdd
(n int32)
sync2/atomic.go:15
↓ 1 callersMethodAfter
(timeout time.Duration)
timingwheel/timingwheel.go:49
↓ 1 callersMethodAfterFunc
(d time.Duration, f func())
time2/wheel.go:271
↓ 1 callersFunctionBytesToInt16
(b []byte)
num/bytes.go:39
↓ 1 callersFunctionBytesToInt32
(b []byte)
num/bytes.go:49
↓ 1 callersFunctionBytesToInt64
(b []byte)
num/bytes.go:59
↓ 1 callersFunctionBytesToUint16
all are bigendian format
num/bytes.go:9
↓ 1 callersFunctionBytesToUint32
(b []byte)
num/bytes.go:19
↓ 1 callersFunctionBytesToUint64
(b []byte)
num/bytes.go:29
↓ 1 callersMethodCapacity
Capacity returns the cache maximum capacity.
cache/lru_cache.go:177
↓ 1 callersMethodClear
Clear will clear the entire cache.
cache/lru_cache.go:123
↓ 1 callersMethodClose
()
log/filehandler.go:88
↓ 1 callersFunctionExecTimeout
exec another process if wait d Duration, it will kill the process d is <= 0, wait forever
exec2/exec.go:11
↓ 1 callersFunctionFatalf
(format string, v ...interface{})
log/log.go:341
↓ 1 callersFunctionFormatInt16
(v int16)
num/str.go:87
↓ 1 callersFunctionFormatInt32
(v int32)
num/str.go:91
← previousnext →101–200 of 607, ranked by callers