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
sequencelengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
sequencelengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
147,400 | rs/zerolog | event.go | MACAddr | func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event {
if e == nil {
return e
}
e.buf = enc.AppendMACAddr(enc.AppendKey(e.buf, key), ha)
return e
} | go | func (e *Event) MACAddr(key string, ha net.HardwareAddr) *Event {
if e == nil {
return e
}
e.buf = enc.AppendMACAddr(enc.AppendKey(e.buf, key), ha)
return e
} | [
"func",
"(",
"e",
"*",
"Event",
")",
"MACAddr",
"(",
"key",
"string",
",",
"ha",
"net",
".",
"HardwareAddr",
")",
"*",
"Event",
"{",
"if",
"e",
"==",
"nil",
"{",
"return",
"e",
"\n",
"}",
"\n",
"e",
".",
"buf",
"=",
"enc",
".",
"AppendMACAddr",
"(",
"enc",
".",
"AppendKey",
"(",
"e",
".",
"buf",
",",
"key",
")",
",",
"ha",
")",
"\n",
"return",
"e",
"\n",
"}"
] | // MACAddr adds MAC address to the event | [
"MACAddr",
"adds",
"MAC",
"address",
"to",
"the",
"event"
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/event.go#L698-L704 |
147,401 | rs/zerolog | internal/json/bytes.go | AppendHex | func (Encoder) AppendHex(dst, s []byte) []byte {
dst = append(dst, '"')
for _, v := range s {
dst = append(dst, hex[v>>4], hex[v&0x0f])
}
return append(dst, '"')
} | go | func (Encoder) AppendHex(dst, s []byte) []byte {
dst = append(dst, '"')
for _, v := range s {
dst = append(dst, hex[v>>4], hex[v&0x0f])
}
return append(dst, '"')
} | [
"func",
"(",
"Encoder",
")",
"AppendHex",
"(",
"dst",
",",
"s",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\"'",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"s",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"hex",
"[",
"v",
">>",
"4",
"]",
",",
"hex",
"[",
"v",
"&",
"0x0f",
"]",
")",
"\n",
"}",
"\n",
"return",
"append",
"(",
"dst",
",",
"'\"'",
")",
"\n",
"}"
] | // AppendHex encodes the input bytes to a hex string and appends
// the encoded string to the input byte slice.
//
// The operation loops though each byte and encodes it as hex using
// the hex lookup table. | [
"AppendHex",
"encodes",
"the",
"input",
"bytes",
"to",
"a",
"hex",
"string",
"and",
"appends",
"the",
"encoded",
"string",
"to",
"the",
"input",
"byte",
"slice",
".",
"The",
"operation",
"loops",
"though",
"each",
"byte",
"and",
"encodes",
"it",
"as",
"hex",
"using",
"the",
"hex",
"lookup",
"table",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/bytes.go#L23-L29 |
147,402 | rs/zerolog | array.go | Arr | func Arr() *Array {
a := arrayPool.Get().(*Array)
a.buf = a.buf[:0]
return a
} | go | func Arr() *Array {
a := arrayPool.Get().(*Array)
a.buf = a.buf[:0]
return a
} | [
"func",
"Arr",
"(",
")",
"*",
"Array",
"{",
"a",
":=",
"arrayPool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"Array",
")",
"\n",
"a",
".",
"buf",
"=",
"a",
".",
"buf",
"[",
":",
"0",
"]",
"\n",
"return",
"a",
"\n",
"}"
] | // Arr creates an array to be added to an Event or Context. | [
"Arr",
"creates",
"an",
"array",
"to",
"be",
"added",
"to",
"an",
"Event",
"or",
"Context",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L38-L42 |
147,403 | rs/zerolog | array.go | Object | func (a *Array) Object(obj LogObjectMarshaler) *Array {
e := Dict()
obj.MarshalZerologObject(e)
e.buf = enc.AppendEndMarker(e.buf)
a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
putEvent(e)
return a
} | go | func (a *Array) Object(obj LogObjectMarshaler) *Array {
e := Dict()
obj.MarshalZerologObject(e)
e.buf = enc.AppendEndMarker(e.buf)
a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
putEvent(e)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Object",
"(",
"obj",
"LogObjectMarshaler",
")",
"*",
"Array",
"{",
"e",
":=",
"Dict",
"(",
")",
"\n",
"obj",
".",
"MarshalZerologObject",
"(",
"e",
")",
"\n",
"e",
".",
"buf",
"=",
"enc",
".",
"AppendEndMarker",
"(",
"e",
".",
"buf",
")",
"\n",
"a",
".",
"buf",
"=",
"append",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"e",
".",
"buf",
"...",
")",
"\n",
"putEvent",
"(",
"e",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Object marshals an object that implement the LogObjectMarshaler
// interface and append append it to the array. | [
"Object",
"marshals",
"an",
"object",
"that",
"implement",
"the",
"LogObjectMarshaler",
"interface",
"and",
"append",
"append",
"it",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L61-L68 |
147,404 | rs/zerolog | array.go | Str | func (a *Array) Str(val string) *Array {
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), val)
return a
} | go | func (a *Array) Str(val string) *Array {
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), val)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Str",
"(",
"val",
"string",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendString",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"val",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Str append append the val as a string to the array. | [
"Str",
"append",
"append",
"the",
"val",
"as",
"a",
"string",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L71-L74 |
147,405 | rs/zerolog | array.go | Bytes | func (a *Array) Bytes(val []byte) *Array {
a.buf = enc.AppendBytes(enc.AppendArrayDelim(a.buf), val)
return a
} | go | func (a *Array) Bytes(val []byte) *Array {
a.buf = enc.AppendBytes(enc.AppendArrayDelim(a.buf), val)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Bytes",
"(",
"val",
"[",
"]",
"byte",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendBytes",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"val",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Bytes append append the val as a string to the array. | [
"Bytes",
"append",
"append",
"the",
"val",
"as",
"a",
"string",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L77-L80 |
147,406 | rs/zerolog | array.go | Hex | func (a *Array) Hex(val []byte) *Array {
a.buf = enc.AppendHex(enc.AppendArrayDelim(a.buf), val)
return a
} | go | func (a *Array) Hex(val []byte) *Array {
a.buf = enc.AppendHex(enc.AppendArrayDelim(a.buf), val)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Hex",
"(",
"val",
"[",
"]",
"byte",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendHex",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"val",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Hex append append the val as a hex string to the array. | [
"Hex",
"append",
"append",
"the",
"val",
"as",
"a",
"hex",
"string",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L83-L86 |
147,407 | rs/zerolog | array.go | Err | func (a *Array) Err(err error) *Array {
marshaled := ErrorMarshalFunc(err)
switch m := marshaled.(type) {
case LogObjectMarshaler:
e := newEvent(nil, 0)
e.buf = e.buf[:0]
e.appendObject(m)
a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
putEvent(e)
case error:
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m.Error())
case string:
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m)
default:
a.buf = enc.AppendInterface(enc.AppendArrayDelim(a.buf), m)
}
return a
} | go | func (a *Array) Err(err error) *Array {
marshaled := ErrorMarshalFunc(err)
switch m := marshaled.(type) {
case LogObjectMarshaler:
e := newEvent(nil, 0)
e.buf = e.buf[:0]
e.appendObject(m)
a.buf = append(enc.AppendArrayDelim(a.buf), e.buf...)
putEvent(e)
case error:
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m.Error())
case string:
a.buf = enc.AppendString(enc.AppendArrayDelim(a.buf), m)
default:
a.buf = enc.AppendInterface(enc.AppendArrayDelim(a.buf), m)
}
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Err",
"(",
"err",
"error",
")",
"*",
"Array",
"{",
"marshaled",
":=",
"ErrorMarshalFunc",
"(",
"err",
")",
"\n",
"switch",
"m",
":=",
"marshaled",
".",
"(",
"type",
")",
"{",
"case",
"LogObjectMarshaler",
":",
"e",
":=",
"newEvent",
"(",
"nil",
",",
"0",
")",
"\n",
"e",
".",
"buf",
"=",
"e",
".",
"buf",
"[",
":",
"0",
"]",
"\n",
"e",
".",
"appendObject",
"(",
"m",
")",
"\n",
"a",
".",
"buf",
"=",
"append",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"e",
".",
"buf",
"...",
")",
"\n",
"putEvent",
"(",
"e",
")",
"\n",
"case",
"error",
":",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendString",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"m",
".",
"Error",
"(",
")",
")",
"\n",
"case",
"string",
":",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendString",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"m",
")",
"\n",
"default",
":",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInterface",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"m",
")",
"\n",
"}",
"\n\n",
"return",
"a",
"\n",
"}"
] | // Err serializes and appends the err to the array. | [
"Err",
"serializes",
"and",
"appends",
"the",
"err",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L89-L107 |
147,408 | rs/zerolog | array.go | Bool | func (a *Array) Bool(b bool) *Array {
a.buf = enc.AppendBool(enc.AppendArrayDelim(a.buf), b)
return a
} | go | func (a *Array) Bool(b bool) *Array {
a.buf = enc.AppendBool(enc.AppendArrayDelim(a.buf), b)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Bool",
"(",
"b",
"bool",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendBool",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"b",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Bool append append the val as a bool to the array. | [
"Bool",
"append",
"append",
"the",
"val",
"as",
"a",
"bool",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L110-L113 |
147,409 | rs/zerolog | array.go | Int | func (a *Array) Int(i int) *Array {
a.buf = enc.AppendInt(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Int(i int) *Array {
a.buf = enc.AppendInt(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Int",
"(",
"i",
"int",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInt",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Int append append i as a int to the array. | [
"Int",
"append",
"append",
"i",
"as",
"a",
"int",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L116-L119 |
147,410 | rs/zerolog | array.go | Int8 | func (a *Array) Int8(i int8) *Array {
a.buf = enc.AppendInt8(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Int8(i int8) *Array {
a.buf = enc.AppendInt8(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Int8",
"(",
"i",
"int8",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInt8",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Int8 append append i as a int8 to the array. | [
"Int8",
"append",
"append",
"i",
"as",
"a",
"int8",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L122-L125 |
147,411 | rs/zerolog | array.go | Int16 | func (a *Array) Int16(i int16) *Array {
a.buf = enc.AppendInt16(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Int16(i int16) *Array {
a.buf = enc.AppendInt16(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Int16",
"(",
"i",
"int16",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInt16",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Int16 append append i as a int16 to the array. | [
"Int16",
"append",
"append",
"i",
"as",
"a",
"int16",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L128-L131 |
147,412 | rs/zerolog | array.go | Int32 | func (a *Array) Int32(i int32) *Array {
a.buf = enc.AppendInt32(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Int32(i int32) *Array {
a.buf = enc.AppendInt32(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Int32",
"(",
"i",
"int32",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInt32",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Int32 append append i as a int32 to the array. | [
"Int32",
"append",
"append",
"i",
"as",
"a",
"int32",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L134-L137 |
147,413 | rs/zerolog | array.go | Int64 | func (a *Array) Int64(i int64) *Array {
a.buf = enc.AppendInt64(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Int64(i int64) *Array {
a.buf = enc.AppendInt64(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Int64",
"(",
"i",
"int64",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInt64",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Int64 append append i as a int64 to the array. | [
"Int64",
"append",
"append",
"i",
"as",
"a",
"int64",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L140-L143 |
147,414 | rs/zerolog | array.go | Uint | func (a *Array) Uint(i uint) *Array {
a.buf = enc.AppendUint(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Uint(i uint) *Array {
a.buf = enc.AppendUint(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Uint",
"(",
"i",
"uint",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendUint",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Uint append append i as a uint to the array. | [
"Uint",
"append",
"append",
"i",
"as",
"a",
"uint",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L146-L149 |
147,415 | rs/zerolog | array.go | Uint8 | func (a *Array) Uint8(i uint8) *Array {
a.buf = enc.AppendUint8(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Uint8(i uint8) *Array {
a.buf = enc.AppendUint8(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Uint8",
"(",
"i",
"uint8",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendUint8",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Uint8 append append i as a uint8 to the array. | [
"Uint8",
"append",
"append",
"i",
"as",
"a",
"uint8",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L152-L155 |
147,416 | rs/zerolog | array.go | Uint16 | func (a *Array) Uint16(i uint16) *Array {
a.buf = enc.AppendUint16(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Uint16(i uint16) *Array {
a.buf = enc.AppendUint16(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Uint16",
"(",
"i",
"uint16",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendUint16",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Uint16 append append i as a uint16 to the array. | [
"Uint16",
"append",
"append",
"i",
"as",
"a",
"uint16",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L158-L161 |
147,417 | rs/zerolog | array.go | Uint32 | func (a *Array) Uint32(i uint32) *Array {
a.buf = enc.AppendUint32(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Uint32(i uint32) *Array {
a.buf = enc.AppendUint32(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Uint32",
"(",
"i",
"uint32",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendUint32",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Uint32 append append i as a uint32 to the array. | [
"Uint32",
"append",
"append",
"i",
"as",
"a",
"uint32",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L164-L167 |
147,418 | rs/zerolog | array.go | Uint64 | func (a *Array) Uint64(i uint64) *Array {
a.buf = enc.AppendUint64(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Uint64(i uint64) *Array {
a.buf = enc.AppendUint64(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Uint64",
"(",
"i",
"uint64",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendUint64",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Uint64 append append i as a uint64 to the array. | [
"Uint64",
"append",
"append",
"i",
"as",
"a",
"uint64",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L170-L173 |
147,419 | rs/zerolog | array.go | Float32 | func (a *Array) Float32(f float32) *Array {
a.buf = enc.AppendFloat32(enc.AppendArrayDelim(a.buf), f)
return a
} | go | func (a *Array) Float32(f float32) *Array {
a.buf = enc.AppendFloat32(enc.AppendArrayDelim(a.buf), f)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Float32",
"(",
"f",
"float32",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendFloat32",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"f",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Float32 append append f as a float32 to the array. | [
"Float32",
"append",
"append",
"f",
"as",
"a",
"float32",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L176-L179 |
147,420 | rs/zerolog | array.go | Float64 | func (a *Array) Float64(f float64) *Array {
a.buf = enc.AppendFloat64(enc.AppendArrayDelim(a.buf), f)
return a
} | go | func (a *Array) Float64(f float64) *Array {
a.buf = enc.AppendFloat64(enc.AppendArrayDelim(a.buf), f)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Float64",
"(",
"f",
"float64",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendFloat64",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"f",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Float64 append append f as a float64 to the array. | [
"Float64",
"append",
"append",
"f",
"as",
"a",
"float64",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L182-L185 |
147,421 | rs/zerolog | array.go | Time | func (a *Array) Time(t time.Time) *Array {
a.buf = enc.AppendTime(enc.AppendArrayDelim(a.buf), t, TimeFieldFormat)
return a
} | go | func (a *Array) Time(t time.Time) *Array {
a.buf = enc.AppendTime(enc.AppendArrayDelim(a.buf), t, TimeFieldFormat)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Time",
"(",
"t",
"time",
".",
"Time",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendTime",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"t",
",",
"TimeFieldFormat",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Time append append t formated as string using zerolog.TimeFieldFormat. | [
"Time",
"append",
"append",
"t",
"formated",
"as",
"string",
"using",
"zerolog",
".",
"TimeFieldFormat",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L188-L191 |
147,422 | rs/zerolog | array.go | Dur | func (a *Array) Dur(d time.Duration) *Array {
a.buf = enc.AppendDuration(enc.AppendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger)
return a
} | go | func (a *Array) Dur(d time.Duration) *Array {
a.buf = enc.AppendDuration(enc.AppendArrayDelim(a.buf), d, DurationFieldUnit, DurationFieldInteger)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Dur",
"(",
"d",
"time",
".",
"Duration",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendDuration",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"d",
",",
"DurationFieldUnit",
",",
"DurationFieldInteger",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Dur append append d to the array. | [
"Dur",
"append",
"append",
"d",
"to",
"the",
"array",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L194-L197 |
147,423 | rs/zerolog | array.go | Interface | func (a *Array) Interface(i interface{}) *Array {
if obj, ok := i.(LogObjectMarshaler); ok {
return a.Object(obj)
}
a.buf = enc.AppendInterface(enc.AppendArrayDelim(a.buf), i)
return a
} | go | func (a *Array) Interface(i interface{}) *Array {
if obj, ok := i.(LogObjectMarshaler); ok {
return a.Object(obj)
}
a.buf = enc.AppendInterface(enc.AppendArrayDelim(a.buf), i)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"Interface",
"(",
"i",
"interface",
"{",
"}",
")",
"*",
"Array",
"{",
"if",
"obj",
",",
"ok",
":=",
"i",
".",
"(",
"LogObjectMarshaler",
")",
";",
"ok",
"{",
"return",
"a",
".",
"Object",
"(",
"obj",
")",
"\n",
"}",
"\n",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendInterface",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"i",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // Interface append append i marshaled using reflection. | [
"Interface",
"append",
"append",
"i",
"marshaled",
"using",
"reflection",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L200-L206 |
147,424 | rs/zerolog | array.go | IPAddr | func (a *Array) IPAddr(ip net.IP) *Array {
a.buf = enc.AppendIPAddr(enc.AppendArrayDelim(a.buf), ip)
return a
} | go | func (a *Array) IPAddr(ip net.IP) *Array {
a.buf = enc.AppendIPAddr(enc.AppendArrayDelim(a.buf), ip)
return a
} | [
"func",
"(",
"a",
"*",
"Array",
")",
"IPAddr",
"(",
"ip",
"net",
".",
"IP",
")",
"*",
"Array",
"{",
"a",
".",
"buf",
"=",
"enc",
".",
"AppendIPAddr",
"(",
"enc",
".",
"AppendArrayDelim",
"(",
"a",
".",
"buf",
")",
",",
"ip",
")",
"\n",
"return",
"a",
"\n",
"}"
] | // IPAddr adds IPv4 or IPv6 address to the array | [
"IPAddr",
"adds",
"IPv4",
"or",
"IPv6",
"address",
"to",
"the",
"array"
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/array.go#L209-L212 |
147,425 | rs/zerolog | internal/json/string.go | AppendStrings | func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = e.AppendString(dst, vals[0])
if len(vals) > 1 {
for _, val := range vals[1:] {
dst = e.AppendString(append(dst, ','), val)
}
}
dst = append(dst, ']')
return dst
} | go | func (e Encoder) AppendStrings(dst []byte, vals []string) []byte {
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = e.AppendString(dst, vals[0])
if len(vals) > 1 {
for _, val := range vals[1:] {
dst = e.AppendString(append(dst, ','), val)
}
}
dst = append(dst, ']')
return dst
} | [
"func",
"(",
"e",
"Encoder",
")",
"AppendStrings",
"(",
"dst",
"[",
"]",
"byte",
",",
"vals",
"[",
"]",
"string",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"vals",
")",
"==",
"0",
"{",
"return",
"append",
"(",
"dst",
",",
"'['",
",",
"']'",
")",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"'['",
")",
"\n",
"dst",
"=",
"e",
".",
"AppendString",
"(",
"dst",
",",
"vals",
"[",
"0",
"]",
")",
"\n",
"if",
"len",
"(",
"vals",
")",
">",
"1",
"{",
"for",
"_",
",",
"val",
":=",
"range",
"vals",
"[",
"1",
":",
"]",
"{",
"dst",
"=",
"e",
".",
"AppendString",
"(",
"append",
"(",
"dst",
",",
"','",
")",
",",
"val",
")",
"\n",
"}",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"']'",
")",
"\n",
"return",
"dst",
"\n",
"}"
] | // AppendStrings encodes the input strings to json and
// appends the encoded string list to the input byte slice. | [
"AppendStrings",
"encodes",
"the",
"input",
"strings",
"to",
"json",
"and",
"appends",
"the",
"encoded",
"string",
"list",
"to",
"the",
"input",
"byte",
"slice",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/string.go#L17-L30 |
147,426 | rs/zerolog | internal/json/string.go | AppendString | func (Encoder) AppendString(dst []byte, s string) []byte {
// Start with a double quote.
dst = append(dst, '"')
// Loop through each character in the string.
for i := 0; i < len(s); i++ {
// Check if the character needs encoding. Control characters, slashes,
// and the double quote need json encoding. Bytes above the ascii
// boundary needs utf8 encoding.
if !noEscapeTable[s[i]] {
// We encountered a character that needs to be encoded. Switch
// to complex version of the algorithm.
dst = appendStringComplex(dst, s, i)
return append(dst, '"')
}
}
// The string has no need for encoding an therefore is directly
// appended to the byte slice.
dst = append(dst, s...)
// End with a double quote
return append(dst, '"')
} | go | func (Encoder) AppendString(dst []byte, s string) []byte {
// Start with a double quote.
dst = append(dst, '"')
// Loop through each character in the string.
for i := 0; i < len(s); i++ {
// Check if the character needs encoding. Control characters, slashes,
// and the double quote need json encoding. Bytes above the ascii
// boundary needs utf8 encoding.
if !noEscapeTable[s[i]] {
// We encountered a character that needs to be encoded. Switch
// to complex version of the algorithm.
dst = appendStringComplex(dst, s, i)
return append(dst, '"')
}
}
// The string has no need for encoding an therefore is directly
// appended to the byte slice.
dst = append(dst, s...)
// End with a double quote
return append(dst, '"')
} | [
"func",
"(",
"Encoder",
")",
"AppendString",
"(",
"dst",
"[",
"]",
"byte",
",",
"s",
"string",
")",
"[",
"]",
"byte",
"{",
"// Start with a double quote.",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\"'",
")",
"\n",
"// Loop through each character in the string.",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"s",
")",
";",
"i",
"++",
"{",
"// Check if the character needs encoding. Control characters, slashes,",
"// and the double quote need json encoding. Bytes above the ascii",
"// boundary needs utf8 encoding.",
"if",
"!",
"noEscapeTable",
"[",
"s",
"[",
"i",
"]",
"]",
"{",
"// We encountered a character that needs to be encoded. Switch",
"// to complex version of the algorithm.",
"dst",
"=",
"appendStringComplex",
"(",
"dst",
",",
"s",
",",
"i",
")",
"\n",
"return",
"append",
"(",
"dst",
",",
"'\"'",
")",
"\n",
"}",
"\n",
"}",
"\n",
"// The string has no need for encoding an therefore is directly",
"// appended to the byte slice.",
"dst",
"=",
"append",
"(",
"dst",
",",
"s",
"...",
")",
"\n",
"// End with a double quote",
"return",
"append",
"(",
"dst",
",",
"'\"'",
")",
"\n",
"}"
] | // AppendString encodes the input string to json and appends
// the encoded string to the input byte slice.
//
// The operation loops though each byte in the string looking
// for characters that need json or utf8 encoding. If the string
// does not need encoding, then the string is appended in it's
// entirety to the byte slice.
// If we encounter a byte that does need encoding, switch up
// the operation and perform a byte-by-byte read-encode-append. | [
"AppendString",
"encodes",
"the",
"input",
"string",
"to",
"json",
"and",
"appends",
"the",
"encoded",
"string",
"to",
"the",
"input",
"byte",
"slice",
".",
"The",
"operation",
"loops",
"though",
"each",
"byte",
"in",
"the",
"string",
"looking",
"for",
"characters",
"that",
"need",
"json",
"or",
"utf8",
"encoding",
".",
"If",
"the",
"string",
"does",
"not",
"need",
"encoding",
"then",
"the",
"string",
"is",
"appended",
"in",
"it",
"s",
"entirety",
"to",
"the",
"byte",
"slice",
".",
"If",
"we",
"encounter",
"a",
"byte",
"that",
"does",
"need",
"encoding",
"switch",
"up",
"the",
"operation",
"and",
"perform",
"a",
"byte",
"-",
"by",
"-",
"byte",
"read",
"-",
"encode",
"-",
"append",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/string.go#L41-L61 |
147,427 | rs/zerolog | internal/json/string.go | appendStringComplex | func appendStringComplex(dst []byte, s string, i int) []byte {
start := 0
for i < len(s) {
b := s[i]
if b >= utf8.RuneSelf {
r, size := utf8.DecodeRuneInString(s[i:])
if r == utf8.RuneError && size == 1 {
// In case of error, first append previous simple characters to
// the byte slice if any and append a remplacement character code
// in place of the invalid sequence.
if start < i {
dst = append(dst, s[start:i]...)
}
dst = append(dst, `\ufffd`...)
i += size
start = i
continue
}
i += size
continue
}
if noEscapeTable[b] {
i++
continue
}
// We encountered a character that needs to be encoded.
// Let's append the previous simple characters to the byte slice
// and switch our operation to read and encode the remainder
// characters byte-by-byte.
if start < i {
dst = append(dst, s[start:i]...)
}
switch b {
case '"', '\\':
dst = append(dst, '\\', b)
case '\b':
dst = append(dst, '\\', 'b')
case '\f':
dst = append(dst, '\\', 'f')
case '\n':
dst = append(dst, '\\', 'n')
case '\r':
dst = append(dst, '\\', 'r')
case '\t':
dst = append(dst, '\\', 't')
default:
dst = append(dst, '\\', 'u', '0', '0', hex[b>>4], hex[b&0xF])
}
i++
start = i
}
if start < len(s) {
dst = append(dst, s[start:]...)
}
return dst
} | go | func appendStringComplex(dst []byte, s string, i int) []byte {
start := 0
for i < len(s) {
b := s[i]
if b >= utf8.RuneSelf {
r, size := utf8.DecodeRuneInString(s[i:])
if r == utf8.RuneError && size == 1 {
// In case of error, first append previous simple characters to
// the byte slice if any and append a remplacement character code
// in place of the invalid sequence.
if start < i {
dst = append(dst, s[start:i]...)
}
dst = append(dst, `\ufffd`...)
i += size
start = i
continue
}
i += size
continue
}
if noEscapeTable[b] {
i++
continue
}
// We encountered a character that needs to be encoded.
// Let's append the previous simple characters to the byte slice
// and switch our operation to read and encode the remainder
// characters byte-by-byte.
if start < i {
dst = append(dst, s[start:i]...)
}
switch b {
case '"', '\\':
dst = append(dst, '\\', b)
case '\b':
dst = append(dst, '\\', 'b')
case '\f':
dst = append(dst, '\\', 'f')
case '\n':
dst = append(dst, '\\', 'n')
case '\r':
dst = append(dst, '\\', 'r')
case '\t':
dst = append(dst, '\\', 't')
default:
dst = append(dst, '\\', 'u', '0', '0', hex[b>>4], hex[b&0xF])
}
i++
start = i
}
if start < len(s) {
dst = append(dst, s[start:]...)
}
return dst
} | [
"func",
"appendStringComplex",
"(",
"dst",
"[",
"]",
"byte",
",",
"s",
"string",
",",
"i",
"int",
")",
"[",
"]",
"byte",
"{",
"start",
":=",
"0",
"\n",
"for",
"i",
"<",
"len",
"(",
"s",
")",
"{",
"b",
":=",
"s",
"[",
"i",
"]",
"\n",
"if",
"b",
">=",
"utf8",
".",
"RuneSelf",
"{",
"r",
",",
"size",
":=",
"utf8",
".",
"DecodeRuneInString",
"(",
"s",
"[",
"i",
":",
"]",
")",
"\n",
"if",
"r",
"==",
"utf8",
".",
"RuneError",
"&&",
"size",
"==",
"1",
"{",
"// In case of error, first append previous simple characters to",
"// the byte slice if any and append a remplacement character code",
"// in place of the invalid sequence.",
"if",
"start",
"<",
"i",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"s",
"[",
"start",
":",
"i",
"]",
"...",
")",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"`\\ufffd`",
"...",
")",
"\n",
"i",
"+=",
"size",
"\n",
"start",
"=",
"i",
"\n",
"continue",
"\n",
"}",
"\n",
"i",
"+=",
"size",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"noEscapeTable",
"[",
"b",
"]",
"{",
"i",
"++",
"\n",
"continue",
"\n",
"}",
"\n",
"// We encountered a character that needs to be encoded.",
"// Let's append the previous simple characters to the byte slice",
"// and switch our operation to read and encode the remainder",
"// characters byte-by-byte.",
"if",
"start",
"<",
"i",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"s",
"[",
"start",
":",
"i",
"]",
"...",
")",
"\n",
"}",
"\n",
"switch",
"b",
"{",
"case",
"'\"'",
",",
"'\\\\'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"b",
")",
"\n",
"case",
"'\\b'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'b'",
")",
"\n",
"case",
"'\\f'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'f'",
")",
"\n",
"case",
"'\\n'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'n'",
")",
"\n",
"case",
"'\\r'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'r'",
")",
"\n",
"case",
"'\\t'",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'t'",
")",
"\n",
"default",
":",
"dst",
"=",
"append",
"(",
"dst",
",",
"'\\\\'",
",",
"'u'",
",",
"'0'",
",",
"'0'",
",",
"hex",
"[",
"b",
">>",
"4",
"]",
",",
"hex",
"[",
"b",
"&",
"0xF",
"]",
")",
"\n",
"}",
"\n",
"i",
"++",
"\n",
"start",
"=",
"i",
"\n",
"}",
"\n",
"if",
"start",
"<",
"len",
"(",
"s",
")",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"s",
"[",
"start",
":",
"]",
"...",
")",
"\n",
"}",
"\n",
"return",
"dst",
"\n",
"}"
] | // appendStringComplex is used by appendString to take over an in
// progress JSON string encoding that encountered a character that needs
// to be encoded. | [
"appendStringComplex",
"is",
"used",
"by",
"appendString",
"to",
"take",
"over",
"an",
"in",
"progress",
"JSON",
"string",
"encoding",
"that",
"encountered",
"a",
"character",
"that",
"needs",
"to",
"be",
"encoded",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/string.go#L66-L121 |
147,428 | rs/zerolog | diode/internal/diodes/poller.go | WithPollingInterval | func WithPollingInterval(interval time.Duration) PollerConfigOption {
return PollerConfigOption(func(c *Poller) {
c.interval = interval
})
} | go | func WithPollingInterval(interval time.Duration) PollerConfigOption {
return PollerConfigOption(func(c *Poller) {
c.interval = interval
})
} | [
"func",
"WithPollingInterval",
"(",
"interval",
"time",
".",
"Duration",
")",
"PollerConfigOption",
"{",
"return",
"PollerConfigOption",
"(",
"func",
"(",
"c",
"*",
"Poller",
")",
"{",
"c",
".",
"interval",
"=",
"interval",
"\n",
"}",
")",
"\n",
"}"
] | // WithPollingInterval sets the interval at which the diode is queried
// for new data. The default is 10ms. | [
"WithPollingInterval",
"sets",
"the",
"interval",
"at",
"which",
"the",
"diode",
"is",
"queried",
"for",
"new",
"data",
".",
"The",
"default",
"is",
"10ms",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/diode/internal/diodes/poller.go#L26-L30 |
147,429 | rs/zerolog | diode/internal/diodes/poller.go | NewPoller | func NewPoller(d Diode, opts ...PollerConfigOption) *Poller {
p := &Poller{
Diode: d,
interval: 10 * time.Millisecond,
ctx: context.Background(),
}
for _, o := range opts {
o(p)
}
return p
} | go | func NewPoller(d Diode, opts ...PollerConfigOption) *Poller {
p := &Poller{
Diode: d,
interval: 10 * time.Millisecond,
ctx: context.Background(),
}
for _, o := range opts {
o(p)
}
return p
} | [
"func",
"NewPoller",
"(",
"d",
"Diode",
",",
"opts",
"...",
"PollerConfigOption",
")",
"*",
"Poller",
"{",
"p",
":=",
"&",
"Poller",
"{",
"Diode",
":",
"d",
",",
"interval",
":",
"10",
"*",
"time",
".",
"Millisecond",
",",
"ctx",
":",
"context",
".",
"Background",
"(",
")",
",",
"}",
"\n\n",
"for",
"_",
",",
"o",
":=",
"range",
"opts",
"{",
"o",
"(",
"p",
")",
"\n",
"}",
"\n\n",
"return",
"p",
"\n",
"}"
] | // NewPoller returns a new Poller that wraps the given diode. | [
"NewPoller",
"returns",
"a",
"new",
"Poller",
"that",
"wraps",
"the",
"given",
"diode",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/diode/internal/diodes/poller.go#L42-L54 |
147,430 | rs/zerolog | diode/internal/diodes/poller.go | Next | func (p *Poller) Next() GenericDataType {
for {
data, ok := p.Diode.TryNext()
if !ok {
if p.isDone() {
return nil
}
time.Sleep(p.interval)
continue
}
return data
}
} | go | func (p *Poller) Next() GenericDataType {
for {
data, ok := p.Diode.TryNext()
if !ok {
if p.isDone() {
return nil
}
time.Sleep(p.interval)
continue
}
return data
}
} | [
"func",
"(",
"p",
"*",
"Poller",
")",
"Next",
"(",
")",
"GenericDataType",
"{",
"for",
"{",
"data",
",",
"ok",
":=",
"p",
".",
"Diode",
".",
"TryNext",
"(",
")",
"\n",
"if",
"!",
"ok",
"{",
"if",
"p",
".",
"isDone",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"time",
".",
"Sleep",
"(",
"p",
".",
"interval",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"data",
"\n",
"}",
"\n",
"}"
] | // Next polls the diode until data is available or until the context is done.
// If the context is done, then nil will be returned. | [
"Next",
"polls",
"the",
"diode",
"until",
"data",
"is",
"available",
"or",
"until",
"the",
"context",
"is",
"done",
".",
"If",
"the",
"context",
"is",
"done",
"then",
"nil",
"will",
"be",
"returned",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/diode/internal/diodes/poller.go#L58-L71 |
147,431 | rs/zerolog | diode/internal/diodes/one_to_one.go | NewOneToOne | func NewOneToOne(size int, alerter Alerter) *OneToOne {
if alerter == nil {
alerter = AlertFunc(func(int) {})
}
return &OneToOne{
buffer: make([]unsafe.Pointer, size),
alerter: alerter,
}
} | go | func NewOneToOne(size int, alerter Alerter) *OneToOne {
if alerter == nil {
alerter = AlertFunc(func(int) {})
}
return &OneToOne{
buffer: make([]unsafe.Pointer, size),
alerter: alerter,
}
} | [
"func",
"NewOneToOne",
"(",
"size",
"int",
",",
"alerter",
"Alerter",
")",
"*",
"OneToOne",
"{",
"if",
"alerter",
"==",
"nil",
"{",
"alerter",
"=",
"AlertFunc",
"(",
"func",
"(",
"int",
")",
"{",
"}",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"OneToOne",
"{",
"buffer",
":",
"make",
"(",
"[",
"]",
"unsafe",
".",
"Pointer",
",",
"size",
")",
",",
"alerter",
":",
"alerter",
",",
"}",
"\n",
"}"
] | // NewOneToOne creates a new diode is meant to be used by a single reader and
// a single writer. The alerter is invoked on the read's go-routine. It is
// called when it notices that the writer go-routine has passed it and wrote
// over data. A nil can be used to ignore alerts. | [
"NewOneToOne",
"creates",
"a",
"new",
"diode",
"is",
"meant",
"to",
"be",
"used",
"by",
"a",
"single",
"reader",
"and",
"a",
"single",
"writer",
".",
"The",
"alerter",
"is",
"invoked",
"on",
"the",
"read",
"s",
"go",
"-",
"routine",
".",
"It",
"is",
"called",
"when",
"it",
"notices",
"that",
"the",
"writer",
"go",
"-",
"routine",
"has",
"passed",
"it",
"and",
"wrote",
"over",
"data",
".",
"A",
"nil",
"can",
"be",
"used",
"to",
"ignore",
"alerts",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/diode/internal/diodes/one_to_one.go#L44-L53 |
147,432 | rs/zerolog | internal/json/base.go | AppendKey | func (e Encoder) AppendKey(dst []byte, key string) []byte {
if len(dst) > 1 && dst[len(dst)-1] != '{' {
dst = append(dst, ',')
}
dst = e.AppendString(dst, key)
return append(dst, ':')
} | go | func (e Encoder) AppendKey(dst []byte, key string) []byte {
if len(dst) > 1 && dst[len(dst)-1] != '{' {
dst = append(dst, ',')
}
dst = e.AppendString(dst, key)
return append(dst, ':')
} | [
"func",
"(",
"e",
"Encoder",
")",
"AppendKey",
"(",
"dst",
"[",
"]",
"byte",
",",
"key",
"string",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"dst",
")",
">",
"1",
"&&",
"dst",
"[",
"len",
"(",
"dst",
")",
"-",
"1",
"]",
"!=",
"'{'",
"{",
"dst",
"=",
"append",
"(",
"dst",
",",
"','",
")",
"\n",
"}",
"\n",
"dst",
"=",
"e",
".",
"AppendString",
"(",
"dst",
",",
"key",
")",
"\n",
"return",
"append",
"(",
"dst",
",",
"':'",
")",
"\n",
"}"
] | // AppendKey appends a new key to the output JSON. | [
"AppendKey",
"appends",
"a",
"new",
"key",
"to",
"the",
"output",
"JSON",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/base.go#L6-L12 |
147,433 | rs/zerolog | internal/json/time.go | AppendTime | func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
switch format {
case timeFormatUnix:
return e.AppendInt64(dst, t.Unix())
case timeFormatUnixMs:
return e.AppendInt64(dst, t.UnixNano()/1000000)
}
return append(t.AppendFormat(append(dst, '"'), format), '"')
} | go | func (e Encoder) AppendTime(dst []byte, t time.Time, format string) []byte {
switch format {
case timeFormatUnix:
return e.AppendInt64(dst, t.Unix())
case timeFormatUnixMs:
return e.AppendInt64(dst, t.UnixNano()/1000000)
}
return append(t.AppendFormat(append(dst, '"'), format), '"')
} | [
"func",
"(",
"e",
"Encoder",
")",
"AppendTime",
"(",
"dst",
"[",
"]",
"byte",
",",
"t",
"time",
".",
"Time",
",",
"format",
"string",
")",
"[",
"]",
"byte",
"{",
"switch",
"format",
"{",
"case",
"timeFormatUnix",
":",
"return",
"e",
".",
"AppendInt64",
"(",
"dst",
",",
"t",
".",
"Unix",
"(",
")",
")",
"\n",
"case",
"timeFormatUnixMs",
":",
"return",
"e",
".",
"AppendInt64",
"(",
"dst",
",",
"t",
".",
"UnixNano",
"(",
")",
"/",
"1000000",
")",
"\n",
"}",
"\n",
"return",
"append",
"(",
"t",
".",
"AppendFormat",
"(",
"append",
"(",
"dst",
",",
"'\"'",
")",
",",
"format",
")",
",",
"'\"'",
")",
"\n",
"}"
] | // AppendTime formats the input time with the given format
// and appends the encoded string to the input byte slice. | [
"AppendTime",
"formats",
"the",
"input",
"time",
"with",
"the",
"given",
"format",
"and",
"appends",
"the",
"encoded",
"string",
"to",
"the",
"input",
"byte",
"slice",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/time.go#L16-L24 |
147,434 | rs/zerolog | internal/json/time.go | AppendTimes | func (Encoder) AppendTimes(dst []byte, vals []time.Time, format string) []byte {
switch format {
case timeFormatUnix:
return appendUnixTimes(dst, vals)
case timeFormatUnixMs:
return appendUnixMsTimes(dst, vals)
}
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = append(vals[0].AppendFormat(append(dst, '"'), format), '"')
if len(vals) > 1 {
for _, t := range vals[1:] {
dst = append(t.AppendFormat(append(dst, ',', '"'), format), '"')
}
}
dst = append(dst, ']')
return dst
} | go | func (Encoder) AppendTimes(dst []byte, vals []time.Time, format string) []byte {
switch format {
case timeFormatUnix:
return appendUnixTimes(dst, vals)
case timeFormatUnixMs:
return appendUnixMsTimes(dst, vals)
}
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = append(vals[0].AppendFormat(append(dst, '"'), format), '"')
if len(vals) > 1 {
for _, t := range vals[1:] {
dst = append(t.AppendFormat(append(dst, ',', '"'), format), '"')
}
}
dst = append(dst, ']')
return dst
} | [
"func",
"(",
"Encoder",
")",
"AppendTimes",
"(",
"dst",
"[",
"]",
"byte",
",",
"vals",
"[",
"]",
"time",
".",
"Time",
",",
"format",
"string",
")",
"[",
"]",
"byte",
"{",
"switch",
"format",
"{",
"case",
"timeFormatUnix",
":",
"return",
"appendUnixTimes",
"(",
"dst",
",",
"vals",
")",
"\n",
"case",
"timeFormatUnixMs",
":",
"return",
"appendUnixMsTimes",
"(",
"dst",
",",
"vals",
")",
"\n",
"}",
"\n",
"if",
"len",
"(",
"vals",
")",
"==",
"0",
"{",
"return",
"append",
"(",
"dst",
",",
"'['",
",",
"']'",
")",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"'['",
")",
"\n",
"dst",
"=",
"append",
"(",
"vals",
"[",
"0",
"]",
".",
"AppendFormat",
"(",
"append",
"(",
"dst",
",",
"'\"'",
")",
",",
"format",
")",
",",
"'\"'",
")",
"\n",
"if",
"len",
"(",
"vals",
")",
">",
"1",
"{",
"for",
"_",
",",
"t",
":=",
"range",
"vals",
"[",
"1",
":",
"]",
"{",
"dst",
"=",
"append",
"(",
"t",
".",
"AppendFormat",
"(",
"append",
"(",
"dst",
",",
"','",
",",
"'\"'",
")",
",",
"format",
")",
",",
"'\"'",
")",
"\n",
"}",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"']'",
")",
"\n",
"return",
"dst",
"\n",
"}"
] | // AppendTimes converts the input times with the given format
// and appends the encoded string list to the input byte slice. | [
"AppendTimes",
"converts",
"the",
"input",
"times",
"with",
"the",
"given",
"format",
"and",
"appends",
"the",
"encoded",
"string",
"list",
"to",
"the",
"input",
"byte",
"slice",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/time.go#L28-L47 |
147,435 | rs/zerolog | internal/json/time.go | AppendDurations | func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = e.AppendDuration(dst, vals[0], unit, useInt)
if len(vals) > 1 {
for _, d := range vals[1:] {
dst = e.AppendDuration(append(dst, ','), d, unit, useInt)
}
}
dst = append(dst, ']')
return dst
} | go | func (e Encoder) AppendDurations(dst []byte, vals []time.Duration, unit time.Duration, useInt bool) []byte {
if len(vals) == 0 {
return append(dst, '[', ']')
}
dst = append(dst, '[')
dst = e.AppendDuration(dst, vals[0], unit, useInt)
if len(vals) > 1 {
for _, d := range vals[1:] {
dst = e.AppendDuration(append(dst, ','), d, unit, useInt)
}
}
dst = append(dst, ']')
return dst
} | [
"func",
"(",
"e",
"Encoder",
")",
"AppendDurations",
"(",
"dst",
"[",
"]",
"byte",
",",
"vals",
"[",
"]",
"time",
".",
"Duration",
",",
"unit",
"time",
".",
"Duration",
",",
"useInt",
"bool",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"vals",
")",
"==",
"0",
"{",
"return",
"append",
"(",
"dst",
",",
"'['",
",",
"']'",
")",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"'['",
")",
"\n",
"dst",
"=",
"e",
".",
"AppendDuration",
"(",
"dst",
",",
"vals",
"[",
"0",
"]",
",",
"unit",
",",
"useInt",
")",
"\n",
"if",
"len",
"(",
"vals",
")",
">",
"1",
"{",
"for",
"_",
",",
"d",
":=",
"range",
"vals",
"[",
"1",
":",
"]",
"{",
"dst",
"=",
"e",
".",
"AppendDuration",
"(",
"append",
"(",
"dst",
",",
"','",
")",
",",
"d",
",",
"unit",
",",
"useInt",
")",
"\n",
"}",
"\n",
"}",
"\n",
"dst",
"=",
"append",
"(",
"dst",
",",
"']'",
")",
"\n",
"return",
"dst",
"\n",
"}"
] | // AppendDurations formats the input durations with the given unit & format
// and appends the encoded string list to the input byte slice. | [
"AppendDurations",
"formats",
"the",
"input",
"durations",
"with",
"the",
"given",
"unit",
"&",
"format",
"and",
"appends",
"the",
"encoded",
"string",
"list",
"to",
"the",
"input",
"byte",
"slice",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/internal/json/time.go#L90-L103 |
147,436 | rs/zerolog | pkgerrors/stacktrace.go | Write | func (s *state) Write(b []byte) (n int, err error) {
s.b = b
return len(b), nil
} | go | func (s *state) Write(b []byte) (n int, err error) {
s.b = b
return len(b), nil
} | [
"func",
"(",
"s",
"*",
"state",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"s",
".",
"b",
"=",
"b",
"\n",
"return",
"len",
"(",
"b",
")",
",",
"nil",
"\n",
"}"
] | // Write implement fmt.Formatter interface. | [
"Write",
"implement",
"fmt",
".",
"Formatter",
"interface",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/pkgerrors/stacktrace.go#L18-L21 |
147,437 | rs/zerolog | hlog/hlog.go | NewHandler | func NewHandler(log zerolog.Logger) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Create a copy of the logger (including internal context slice)
// to prevent data race when using UpdateContext.
l := log.With().Logger()
r = r.WithContext(l.WithContext(r.Context()))
next.ServeHTTP(w, r)
})
}
} | go | func NewHandler(log zerolog.Logger) func(http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Create a copy of the logger (including internal context slice)
// to prevent data race when using UpdateContext.
l := log.With().Logger()
r = r.WithContext(l.WithContext(r.Context()))
next.ServeHTTP(w, r)
})
}
} | [
"func",
"NewHandler",
"(",
"log",
"zerolog",
".",
"Logger",
")",
"func",
"(",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"// Create a copy of the logger (including internal context slice)",
"// to prevent data race when using UpdateContext.",
"l",
":=",
"log",
".",
"With",
"(",
")",
".",
"Logger",
"(",
")",
"\n",
"r",
"=",
"r",
".",
"WithContext",
"(",
"l",
".",
"WithContext",
"(",
"r",
".",
"Context",
"(",
")",
")",
")",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // NewHandler injects log into requests context. | [
"NewHandler",
"injects",
"log",
"into",
"requests",
"context",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L23-L33 |
147,438 | rs/zerolog | hlog/hlog.go | RequestHandler | func RequestHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, r.Method+" "+r.URL.String())
})
next.ServeHTTP(w, r)
})
}
} | go | func RequestHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, r.Method+" "+r.URL.String())
})
next.ServeHTTP(w, r)
})
}
} | [
"func",
"RequestHandler",
"(",
"fieldKey",
"string",
")",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"log",
":=",
"zerolog",
".",
"Ctx",
"(",
"r",
".",
"Context",
"(",
")",
")",
"\n",
"log",
".",
"UpdateContext",
"(",
"func",
"(",
"c",
"zerolog",
".",
"Context",
")",
"zerolog",
".",
"Context",
"{",
"return",
"c",
".",
"Str",
"(",
"fieldKey",
",",
"r",
".",
"Method",
"+",
"\"",
"\"",
"+",
"r",
".",
"URL",
".",
"String",
"(",
")",
")",
"\n",
"}",
")",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // RequestHandler adds the request method and URL as a field to the context's logger
// using fieldKey as field key. | [
"RequestHandler",
"adds",
"the",
"request",
"method",
"and",
"URL",
"as",
"a",
"field",
"to",
"the",
"context",
"s",
"logger",
"using",
"fieldKey",
"as",
"field",
"key",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L65-L75 |
147,439 | rs/zerolog | hlog/hlog.go | RemoteAddrHandler | func RemoteAddrHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if host, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, host)
})
}
next.ServeHTTP(w, r)
})
}
} | go | func RemoteAddrHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if host, _, err := net.SplitHostPort(r.RemoteAddr); err == nil {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, host)
})
}
next.ServeHTTP(w, r)
})
}
} | [
"func",
"RemoteAddrHandler",
"(",
"fieldKey",
"string",
")",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"host",
",",
"_",
",",
"err",
":=",
"net",
".",
"SplitHostPort",
"(",
"r",
".",
"RemoteAddr",
")",
";",
"err",
"==",
"nil",
"{",
"log",
":=",
"zerolog",
".",
"Ctx",
"(",
"r",
".",
"Context",
"(",
")",
")",
"\n",
"log",
".",
"UpdateContext",
"(",
"func",
"(",
"c",
"zerolog",
".",
"Context",
")",
"zerolog",
".",
"Context",
"{",
"return",
"c",
".",
"Str",
"(",
"fieldKey",
",",
"host",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // RemoteAddrHandler adds the request's remote address as a field to the context's logger
// using fieldKey as field key. | [
"RemoteAddrHandler",
"adds",
"the",
"request",
"s",
"remote",
"address",
"as",
"a",
"field",
"to",
"the",
"context",
"s",
"logger",
"using",
"fieldKey",
"as",
"field",
"key",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L79-L91 |
147,440 | rs/zerolog | hlog/hlog.go | UserAgentHandler | func UserAgentHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if ua := r.Header.Get("User-Agent"); ua != "" {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, ua)
})
}
next.ServeHTTP(w, r)
})
}
} | go | func UserAgentHandler(fieldKey string) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if ua := r.Header.Get("User-Agent"); ua != "" {
log := zerolog.Ctx(r.Context())
log.UpdateContext(func(c zerolog.Context) zerolog.Context {
return c.Str(fieldKey, ua)
})
}
next.ServeHTTP(w, r)
})
}
} | [
"func",
"UserAgentHandler",
"(",
"fieldKey",
"string",
")",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"if",
"ua",
":=",
"r",
".",
"Header",
".",
"Get",
"(",
"\"",
"\"",
")",
";",
"ua",
"!=",
"\"",
"\"",
"{",
"log",
":=",
"zerolog",
".",
"Ctx",
"(",
"r",
".",
"Context",
"(",
")",
")",
"\n",
"log",
".",
"UpdateContext",
"(",
"func",
"(",
"c",
"zerolog",
".",
"Context",
")",
"zerolog",
".",
"Context",
"{",
"return",
"c",
".",
"Str",
"(",
"fieldKey",
",",
"ua",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"next",
".",
"ServeHTTP",
"(",
"w",
",",
"r",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // UserAgentHandler adds the request's user-agent as a field to the context's logger
// using fieldKey as field key. | [
"UserAgentHandler",
"adds",
"the",
"request",
"s",
"user",
"-",
"agent",
"as",
"a",
"field",
"to",
"the",
"context",
"s",
"logger",
"using",
"fieldKey",
"as",
"field",
"key",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L95-L107 |
147,441 | rs/zerolog | hlog/hlog.go | IDFromRequest | func IDFromRequest(r *http.Request) (id xid.ID, ok bool) {
if r == nil {
return
}
return IDFromCtx(r.Context())
} | go | func IDFromRequest(r *http.Request) (id xid.ID, ok bool) {
if r == nil {
return
}
return IDFromCtx(r.Context())
} | [
"func",
"IDFromRequest",
"(",
"r",
"*",
"http",
".",
"Request",
")",
"(",
"id",
"xid",
".",
"ID",
",",
"ok",
"bool",
")",
"{",
"if",
"r",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"IDFromCtx",
"(",
"r",
".",
"Context",
"(",
")",
")",
"\n",
"}"
] | // IDFromRequest returns the unique id associated to the request if any. | [
"IDFromRequest",
"returns",
"the",
"unique",
"id",
"associated",
"to",
"the",
"request",
"if",
"any",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L128-L133 |
147,442 | rs/zerolog | hlog/hlog.go | AccessHandler | func AccessHandler(f func(r *http.Request, status, size int, duration time.Duration)) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
lw := mutil.WrapWriter(w)
next.ServeHTTP(lw, r)
f(r, lw.Status(), lw.BytesWritten(), time.Since(start))
})
}
} | go | func AccessHandler(f func(r *http.Request, status, size int, duration time.Duration)) func(next http.Handler) http.Handler {
return func(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
lw := mutil.WrapWriter(w)
next.ServeHTTP(lw, r)
f(r, lw.Status(), lw.BytesWritten(), time.Since(start))
})
}
} | [
"func",
"AccessHandler",
"(",
"f",
"func",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"status",
",",
"size",
"int",
",",
"duration",
"time",
".",
"Duration",
")",
")",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"func",
"(",
"next",
"http",
".",
"Handler",
")",
"http",
".",
"Handler",
"{",
"return",
"http",
".",
"HandlerFunc",
"(",
"func",
"(",
"w",
"http",
".",
"ResponseWriter",
",",
"r",
"*",
"http",
".",
"Request",
")",
"{",
"start",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"lw",
":=",
"mutil",
".",
"WrapWriter",
"(",
"w",
")",
"\n",
"next",
".",
"ServeHTTP",
"(",
"lw",
",",
"r",
")",
"\n",
"f",
"(",
"r",
",",
"lw",
".",
"Status",
"(",
")",
",",
"lw",
".",
"BytesWritten",
"(",
")",
",",
"time",
".",
"Since",
"(",
"start",
")",
")",
"\n",
"}",
")",
"\n",
"}",
"\n",
"}"
] | // AccessHandler returns a handler that call f after each request. | [
"AccessHandler",
"returns",
"a",
"handler",
"that",
"call",
"f",
"after",
"each",
"request",
"."
] | acf3980132bfcdc48638724e6e3d9e5749b85999 | https://github.com/rs/zerolog/blob/acf3980132bfcdc48638724e6e3d9e5749b85999/hlog/hlog.go#L175-L184 |
147,443 | rebuy-de/aws-nuke | cmd/queue.go | List | func (i *Item) List() ([]resources.Resource, error) {
listers := resources.GetListers()
return listers[i.Type](i.Region.Session)
} | go | func (i *Item) List() ([]resources.Resource, error) {
listers := resources.GetListers()
return listers[i.Type](i.Region.Session)
} | [
"func",
"(",
"i",
"*",
"Item",
")",
"List",
"(",
")",
"(",
"[",
"]",
"resources",
".",
"Resource",
",",
"error",
")",
"{",
"listers",
":=",
"resources",
".",
"GetListers",
"(",
")",
"\n",
"return",
"listers",
"[",
"i",
".",
"Type",
"]",
"(",
"i",
".",
"Region",
".",
"Session",
")",
"\n",
"}"
] | // List gets all resource items of the same resource type like the Item. | [
"List",
"gets",
"all",
"resource",
"items",
"of",
"the",
"same",
"resource",
"type",
"like",
"the",
"Item",
"."
] | 21582790b6806fd775aba073b0bbc27a111a15f0 | https://github.com/rebuy-de/aws-nuke/blob/21582790b6806fd775aba073b0bbc27a111a15f0/cmd/queue.go#L51-L54 |
147,444 | wcharczuk/go-chart | util/math.go | Max | func (m mathUtil) Max(values ...float64) float64 {
if len(values) == 0 {
return 0
}
max := values[0]
for _, v := range values {
if max < v {
max = v
}
}
return max
} | go | func (m mathUtil) Max(values ...float64) float64 {
if len(values) == 0 {
return 0
}
max := values[0]
for _, v := range values {
if max < v {
max = v
}
}
return max
} | [
"func",
"(",
"m",
"mathUtil",
")",
"Max",
"(",
"values",
"...",
"float64",
")",
"float64",
"{",
"if",
"len",
"(",
"values",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"max",
":=",
"values",
"[",
"0",
"]",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"if",
"max",
"<",
"v",
"{",
"max",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"max",
"\n",
"}"
] | // Max returns the maximum value of a group of floats. | [
"Max",
"returns",
"the",
"maximum",
"value",
"of",
"a",
"group",
"of",
"floats",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L29-L40 |
147,445 | wcharczuk/go-chart | util/math.go | MinAndMax | func (m mathUtil) MinAndMax(values ...float64) (min float64, max float64) {
if len(values) == 0 {
return
}
min = values[0]
max = values[0]
for _, v := range values[1:] {
if max < v {
max = v
}
if min > v {
min = v
}
}
return
} | go | func (m mathUtil) MinAndMax(values ...float64) (min float64, max float64) {
if len(values) == 0 {
return
}
min = values[0]
max = values[0]
for _, v := range values[1:] {
if max < v {
max = v
}
if min > v {
min = v
}
}
return
} | [
"func",
"(",
"m",
"mathUtil",
")",
"MinAndMax",
"(",
"values",
"...",
"float64",
")",
"(",
"min",
"float64",
",",
"max",
"float64",
")",
"{",
"if",
"len",
"(",
"values",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"min",
"=",
"values",
"[",
"0",
"]",
"\n",
"max",
"=",
"values",
"[",
"0",
"]",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"[",
"1",
":",
"]",
"{",
"if",
"max",
"<",
"v",
"{",
"max",
"=",
"v",
"\n",
"}",
"\n",
"if",
"min",
">",
"v",
"{",
"min",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // MinAndMax returns both the min and max in one pass. | [
"MinAndMax",
"returns",
"both",
"the",
"min",
"and",
"max",
"in",
"one",
"pass",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L43-L58 |
147,446 | wcharczuk/go-chart | util/math.go | GetRoundToForDelta | func (m mathUtil) GetRoundToForDelta(delta float64) float64 {
startingDeltaBound := math.Pow(10.0, 10.0)
for cursor := startingDeltaBound; cursor > 0; cursor /= 10.0 {
if delta > cursor {
return cursor / 10.0
}
}
return 0.0
} | go | func (m mathUtil) GetRoundToForDelta(delta float64) float64 {
startingDeltaBound := math.Pow(10.0, 10.0)
for cursor := startingDeltaBound; cursor > 0; cursor /= 10.0 {
if delta > cursor {
return cursor / 10.0
}
}
return 0.0
} | [
"func",
"(",
"m",
"mathUtil",
")",
"GetRoundToForDelta",
"(",
"delta",
"float64",
")",
"float64",
"{",
"startingDeltaBound",
":=",
"math",
".",
"Pow",
"(",
"10.0",
",",
"10.0",
")",
"\n",
"for",
"cursor",
":=",
"startingDeltaBound",
";",
"cursor",
">",
"0",
";",
"cursor",
"/=",
"10.0",
"{",
"if",
"delta",
">",
"cursor",
"{",
"return",
"cursor",
"/",
"10.0",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"0.0",
"\n",
"}"
] | // GetRoundToForDelta returns a `roundTo` value for a given delta. | [
"GetRoundToForDelta",
"returns",
"a",
"roundTo",
"value",
"for",
"a",
"given",
"delta",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L61-L70 |
147,447 | wcharczuk/go-chart | util/math.go | RoundUp | func (m mathUtil) RoundUp(value, roundTo float64) float64 {
if roundTo < 0.000000000000001 {
return value
}
d1 := math.Ceil(value / roundTo)
return d1 * roundTo
} | go | func (m mathUtil) RoundUp(value, roundTo float64) float64 {
if roundTo < 0.000000000000001 {
return value
}
d1 := math.Ceil(value / roundTo)
return d1 * roundTo
} | [
"func",
"(",
"m",
"mathUtil",
")",
"RoundUp",
"(",
"value",
",",
"roundTo",
"float64",
")",
"float64",
"{",
"if",
"roundTo",
"<",
"0.000000000000001",
"{",
"return",
"value",
"\n",
"}",
"\n",
"d1",
":=",
"math",
".",
"Ceil",
"(",
"value",
"/",
"roundTo",
")",
"\n",
"return",
"d1",
"*",
"roundTo",
"\n",
"}"
] | // RoundUp rounds up to a given roundTo value. | [
"RoundUp",
"rounds",
"up",
"to",
"a",
"given",
"roundTo",
"value",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L73-L79 |
147,448 | wcharczuk/go-chart | util/math.go | RoundDown | func (m mathUtil) RoundDown(value, roundTo float64) float64 {
if roundTo < 0.000000000000001 {
return value
}
d1 := math.Floor(value / roundTo)
return d1 * roundTo
} | go | func (m mathUtil) RoundDown(value, roundTo float64) float64 {
if roundTo < 0.000000000000001 {
return value
}
d1 := math.Floor(value / roundTo)
return d1 * roundTo
} | [
"func",
"(",
"m",
"mathUtil",
")",
"RoundDown",
"(",
"value",
",",
"roundTo",
"float64",
")",
"float64",
"{",
"if",
"roundTo",
"<",
"0.000000000000001",
"{",
"return",
"value",
"\n",
"}",
"\n",
"d1",
":=",
"math",
".",
"Floor",
"(",
"value",
"/",
"roundTo",
")",
"\n",
"return",
"d1",
"*",
"roundTo",
"\n",
"}"
] | // RoundDown rounds down to a given roundTo value. | [
"RoundDown",
"rounds",
"down",
"to",
"a",
"given",
"roundTo",
"value",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L82-L88 |
147,449 | wcharczuk/go-chart | util/math.go | MinInt | func (m mathUtil) MinInt(values ...int) int {
min := math.MaxInt32
for _, v := range values {
if v < min {
min = v
}
}
return min
} | go | func (m mathUtil) MinInt(values ...int) int {
min := math.MaxInt32
for _, v := range values {
if v < min {
min = v
}
}
return min
} | [
"func",
"(",
"m",
"mathUtil",
")",
"MinInt",
"(",
"values",
"...",
"int",
")",
"int",
"{",
"min",
":=",
"math",
".",
"MaxInt32",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"if",
"v",
"<",
"min",
"{",
"min",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"min",
"\n",
"}"
] | // MinInt returns the minimum of a set of integers. | [
"MinInt",
"returns",
"the",
"minimum",
"of",
"a",
"set",
"of",
"integers",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L106-L114 |
147,450 | wcharczuk/go-chart | util/math.go | MaxInt | func (m mathUtil) MaxInt(values ...int) int {
max := math.MinInt32
for _, v := range values {
if v > max {
max = v
}
}
return max
} | go | func (m mathUtil) MaxInt(values ...int) int {
max := math.MinInt32
for _, v := range values {
if v > max {
max = v
}
}
return max
} | [
"func",
"(",
"m",
"mathUtil",
")",
"MaxInt",
"(",
"values",
"...",
"int",
")",
"int",
"{",
"max",
":=",
"math",
".",
"MinInt32",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"if",
"v",
">",
"max",
"{",
"max",
"=",
"v",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"max",
"\n",
"}"
] | // MaxInt returns the maximum of a set of integers. | [
"MaxInt",
"returns",
"the",
"maximum",
"of",
"a",
"set",
"of",
"integers",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L117-L125 |
147,451 | wcharczuk/go-chart | util/math.go | Mean | func (m mathUtil) Mean(values ...float64) float64 {
return m.Sum(values...) / float64(len(values))
} | go | func (m mathUtil) Mean(values ...float64) float64 {
return m.Sum(values...) / float64(len(values))
} | [
"func",
"(",
"m",
"mathUtil",
")",
"Mean",
"(",
"values",
"...",
"float64",
")",
"float64",
"{",
"return",
"m",
".",
"Sum",
"(",
"values",
"...",
")",
"/",
"float64",
"(",
"len",
"(",
"values",
")",
")",
"\n",
"}"
] | // Mean returns the mean of a set of values | [
"Mean",
"returns",
"the",
"mean",
"of",
"a",
"set",
"of",
"values"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L144-L146 |
147,452 | wcharczuk/go-chart | util/math.go | MeanInt | func (m mathUtil) MeanInt(values ...int) int {
return m.SumInt(values...) / len(values)
} | go | func (m mathUtil) MeanInt(values ...int) int {
return m.SumInt(values...) / len(values)
} | [
"func",
"(",
"m",
"mathUtil",
")",
"MeanInt",
"(",
"values",
"...",
"int",
")",
"int",
"{",
"return",
"m",
".",
"SumInt",
"(",
"values",
"...",
")",
"/",
"len",
"(",
"values",
")",
"\n",
"}"
] | // MeanInt returns the mean of a set of integer values. | [
"MeanInt",
"returns",
"the",
"mean",
"of",
"a",
"set",
"of",
"integer",
"values",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L149-L151 |
147,453 | wcharczuk/go-chart | util/math.go | Sum | func (m mathUtil) Sum(values ...float64) float64 {
var total float64
for _, v := range values {
total += v
}
return total
} | go | func (m mathUtil) Sum(values ...float64) float64 {
var total float64
for _, v := range values {
total += v
}
return total
} | [
"func",
"(",
"m",
"mathUtil",
")",
"Sum",
"(",
"values",
"...",
"float64",
")",
"float64",
"{",
"var",
"total",
"float64",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"total",
"+=",
"v",
"\n",
"}",
"\n",
"return",
"total",
"\n",
"}"
] | // Sum sums a set of values. | [
"Sum",
"sums",
"a",
"set",
"of",
"values",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L154-L160 |
147,454 | wcharczuk/go-chart | util/math.go | SumInt | func (m mathUtil) SumInt(values ...int) int {
var total int
for _, v := range values {
total += v
}
return total
} | go | func (m mathUtil) SumInt(values ...int) int {
var total int
for _, v := range values {
total += v
}
return total
} | [
"func",
"(",
"m",
"mathUtil",
")",
"SumInt",
"(",
"values",
"...",
"int",
")",
"int",
"{",
"var",
"total",
"int",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"values",
"{",
"total",
"+=",
"v",
"\n",
"}",
"\n",
"return",
"total",
"\n",
"}"
] | // SumInt sums a set of values. | [
"SumInt",
"sums",
"a",
"set",
"of",
"values",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L163-L169 |
147,455 | wcharczuk/go-chart | util/math.go | RadiansToDegrees | func (m mathUtil) RadiansToDegrees(value float64) float64 {
return math.Mod(value, _2pi) * _r2d
} | go | func (m mathUtil) RadiansToDegrees(value float64) float64 {
return math.Mod(value, _2pi) * _r2d
} | [
"func",
"(",
"m",
"mathUtil",
")",
"RadiansToDegrees",
"(",
"value",
"float64",
")",
"float64",
"{",
"return",
"math",
".",
"Mod",
"(",
"value",
",",
"_2pi",
")",
"*",
"_r2d",
"\n",
"}"
] | // RadiansToDegrees translates a radian value to a degree value. | [
"RadiansToDegrees",
"translates",
"a",
"radian",
"value",
"to",
"a",
"degree",
"value",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L186-L188 |
147,456 | wcharczuk/go-chart | util/math.go | RadianAdd | func (m mathUtil) RadianAdd(base, delta float64) float64 {
value := base + delta
if value > _2pi {
return math.Mod(value, _2pi)
} else if value < 0 {
return math.Mod(_2pi+value, _2pi)
}
return value
} | go | func (m mathUtil) RadianAdd(base, delta float64) float64 {
value := base + delta
if value > _2pi {
return math.Mod(value, _2pi)
} else if value < 0 {
return math.Mod(_2pi+value, _2pi)
}
return value
} | [
"func",
"(",
"m",
"mathUtil",
")",
"RadianAdd",
"(",
"base",
",",
"delta",
"float64",
")",
"float64",
"{",
"value",
":=",
"base",
"+",
"delta",
"\n",
"if",
"value",
">",
"_2pi",
"{",
"return",
"math",
".",
"Mod",
"(",
"value",
",",
"_2pi",
")",
"\n",
"}",
"else",
"if",
"value",
"<",
"0",
"{",
"return",
"math",
".",
"Mod",
"(",
"_2pi",
"+",
"value",
",",
"_2pi",
")",
"\n",
"}",
"\n",
"return",
"value",
"\n",
"}"
] | // RadianAdd adds a delta to a base in radians. | [
"RadianAdd",
"adds",
"a",
"delta",
"to",
"a",
"base",
"in",
"radians",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L196-L204 |
147,457 | wcharczuk/go-chart | util/math.go | DegreesAdd | func (m mathUtil) DegreesAdd(baseDegrees, deltaDegrees float64) float64 {
value := baseDegrees + deltaDegrees
if value > _2pi {
return math.Mod(value, 360.0)
} else if value < 0 {
return math.Mod(360.0+value, 360.0)
}
return value
} | go | func (m mathUtil) DegreesAdd(baseDegrees, deltaDegrees float64) float64 {
value := baseDegrees + deltaDegrees
if value > _2pi {
return math.Mod(value, 360.0)
} else if value < 0 {
return math.Mod(360.0+value, 360.0)
}
return value
} | [
"func",
"(",
"m",
"mathUtil",
")",
"DegreesAdd",
"(",
"baseDegrees",
",",
"deltaDegrees",
"float64",
")",
"float64",
"{",
"value",
":=",
"baseDegrees",
"+",
"deltaDegrees",
"\n",
"if",
"value",
">",
"_2pi",
"{",
"return",
"math",
".",
"Mod",
"(",
"value",
",",
"360.0",
")",
"\n",
"}",
"else",
"if",
"value",
"<",
"0",
"{",
"return",
"math",
".",
"Mod",
"(",
"360.0",
"+",
"value",
",",
"360.0",
")",
"\n",
"}",
"\n",
"return",
"value",
"\n",
"}"
] | // DegreesAdd adds a delta to a base in radians. | [
"DegreesAdd",
"adds",
"a",
"delta",
"to",
"a",
"base",
"in",
"radians",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L207-L215 |
147,458 | wcharczuk/go-chart | util/math.go | CirclePoint | func (m mathUtil) CirclePoint(cx, cy int, radius, thetaRadians float64) (x, y int) {
x = cx + int(radius*math.Sin(thetaRadians))
y = cy - int(radius*math.Cos(thetaRadians))
return
} | go | func (m mathUtil) CirclePoint(cx, cy int, radius, thetaRadians float64) (x, y int) {
x = cx + int(radius*math.Sin(thetaRadians))
y = cy - int(radius*math.Cos(thetaRadians))
return
} | [
"func",
"(",
"m",
"mathUtil",
")",
"CirclePoint",
"(",
"cx",
",",
"cy",
"int",
",",
"radius",
",",
"thetaRadians",
"float64",
")",
"(",
"x",
",",
"y",
"int",
")",
"{",
"x",
"=",
"cx",
"+",
"int",
"(",
"radius",
"*",
"math",
".",
"Sin",
"(",
"thetaRadians",
")",
")",
"\n",
"y",
"=",
"cy",
"-",
"int",
"(",
"radius",
"*",
"math",
".",
"Cos",
"(",
"thetaRadians",
")",
")",
"\n",
"return",
"\n",
"}"
] | // CirclePoint returns the absolute position of a circle diameter point given
// by the radius and the theta. | [
"CirclePoint",
"returns",
"the",
"absolute",
"position",
"of",
"a",
"circle",
"diameter",
"point",
"given",
"by",
"the",
"radius",
"and",
"the",
"theta",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/util/math.go#L224-L228 |
147,459 | wcharczuk/go-chart | seq/seq.go | Array | func (s Seq) Array() (output []float64) {
if s.Len() == 0 {
return
}
output = make([]float64, s.Len())
for i := 0; i < s.Len(); i++ {
output[i] = s.GetValue(i)
}
return
} | go | func (s Seq) Array() (output []float64) {
if s.Len() == 0 {
return
}
output = make([]float64, s.Len())
for i := 0; i < s.Len(); i++ {
output[i] = s.GetValue(i)
}
return
} | [
"func",
"(",
"s",
"Seq",
")",
"Array",
"(",
")",
"(",
"output",
"[",
"]",
"float64",
")",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"output",
"=",
"make",
"(",
"[",
"]",
"float64",
",",
"s",
".",
"Len",
"(",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"output",
"[",
"i",
"]",
"=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Array enumerates the seq into a slice. | [
"Array",
"enumerates",
"the",
"seq",
"into",
"a",
"slice",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L30-L40 |
147,460 | wcharczuk/go-chart | seq/seq.go | Each | func (s Seq) Each(mapfn func(int, float64)) {
for i := 0; i < s.Len(); i++ {
mapfn(i, s.GetValue(i))
}
} | go | func (s Seq) Each(mapfn func(int, float64)) {
for i := 0; i < s.Len(); i++ {
mapfn(i, s.GetValue(i))
}
} | [
"func",
"(",
"s",
"Seq",
")",
"Each",
"(",
"mapfn",
"func",
"(",
"int",
",",
"float64",
")",
")",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"mapfn",
"(",
"i",
",",
"s",
".",
"GetValue",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"}"
] | // Each applies the `mapfn` to all values in the value provider. | [
"Each",
"applies",
"the",
"mapfn",
"to",
"all",
"values",
"in",
"the",
"value",
"provider",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L43-L47 |
147,461 | wcharczuk/go-chart | seq/seq.go | Map | func (s Seq) Map(mapfn func(i int, v float64) float64) Seq {
output := make([]float64, s.Len())
for i := 0; i < s.Len(); i++ {
mapfn(i, s.GetValue(i))
}
return Seq{Array(output)}
} | go | func (s Seq) Map(mapfn func(i int, v float64) float64) Seq {
output := make([]float64, s.Len())
for i := 0; i < s.Len(); i++ {
mapfn(i, s.GetValue(i))
}
return Seq{Array(output)}
} | [
"func",
"(",
"s",
"Seq",
")",
"Map",
"(",
"mapfn",
"func",
"(",
"i",
"int",
",",
"v",
"float64",
")",
"float64",
")",
"Seq",
"{",
"output",
":=",
"make",
"(",
"[",
"]",
"float64",
",",
"s",
".",
"Len",
"(",
")",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"mapfn",
"(",
"i",
",",
"s",
".",
"GetValue",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"Seq",
"{",
"Array",
"(",
"output",
")",
"}",
"\n",
"}"
] | // Map applies the `mapfn` to all values in the value provider,
// returning a new seq. | [
"Map",
"applies",
"the",
"mapfn",
"to",
"all",
"values",
"in",
"the",
"value",
"provider",
"returning",
"a",
"new",
"seq",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L51-L57 |
147,462 | wcharczuk/go-chart | seq/seq.go | FoldRight | func (s Seq) FoldRight(mapfn func(i int, v0, v float64) float64) (v0 float64) {
if s.Len() == 0 {
return 0
}
if s.Len() == 1 {
return s.GetValue(0)
}
v0 = s.GetValue(s.Len() - 1)
for i := s.Len() - 2; i >= 0; i-- {
v0 = mapfn(i, v0, s.GetValue(i))
}
return
} | go | func (s Seq) FoldRight(mapfn func(i int, v0, v float64) float64) (v0 float64) {
if s.Len() == 0 {
return 0
}
if s.Len() == 1 {
return s.GetValue(0)
}
v0 = s.GetValue(s.Len() - 1)
for i := s.Len() - 2; i >= 0; i-- {
v0 = mapfn(i, v0, s.GetValue(i))
}
return
} | [
"func",
"(",
"s",
"Seq",
")",
"FoldRight",
"(",
"mapfn",
"func",
"(",
"i",
"int",
",",
"v0",
",",
"v",
"float64",
")",
"float64",
")",
"(",
"v0",
"float64",
")",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"1",
"{",
"return",
"s",
".",
"GetValue",
"(",
"0",
")",
"\n",
"}",
"\n\n",
"v0",
"=",
"s",
".",
"GetValue",
"(",
"s",
".",
"Len",
"(",
")",
"-",
"1",
")",
"\n",
"for",
"i",
":=",
"s",
".",
"Len",
"(",
")",
"-",
"2",
";",
"i",
">=",
"0",
";",
"i",
"--",
"{",
"v0",
"=",
"mapfn",
"(",
"i",
",",
"v0",
",",
"s",
".",
"GetValue",
"(",
"i",
")",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // FoldRight collapses a seq from right to left. | [
"FoldRight",
"collapses",
"a",
"seq",
"from",
"right",
"to",
"left",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L77-L91 |
147,463 | wcharczuk/go-chart | seq/seq.go | Min | func (s Seq) Min() float64 {
if s.Len() == 0 {
return 0
}
min := s.GetValue(0)
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value < min {
min = value
}
}
return min
} | go | func (s Seq) Min() float64 {
if s.Len() == 0 {
return 0
}
min := s.GetValue(0)
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value < min {
min = value
}
}
return min
} | [
"func",
"(",
"s",
"Seq",
")",
"Min",
"(",
")",
"float64",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"min",
":=",
"s",
".",
"GetValue",
"(",
"0",
")",
"\n",
"var",
"value",
"float64",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"value",
"=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"if",
"value",
"<",
"min",
"{",
"min",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"min",
"\n",
"}"
] | // Min returns the minimum value in the seq. | [
"Min",
"returns",
"the",
"minimum",
"value",
"in",
"the",
"seq",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L94-L107 |
147,464 | wcharczuk/go-chart | seq/seq.go | Max | func (s Seq) Max() float64 {
if s.Len() == 0 {
return 0
}
max := s.GetValue(0)
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value > max {
max = value
}
}
return max
} | go | func (s Seq) Max() float64 {
if s.Len() == 0 {
return 0
}
max := s.GetValue(0)
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value > max {
max = value
}
}
return max
} | [
"func",
"(",
"s",
"Seq",
")",
"Max",
"(",
")",
"float64",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n",
"max",
":=",
"s",
".",
"GetValue",
"(",
"0",
")",
"\n",
"var",
"value",
"float64",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"value",
"=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"if",
"value",
">",
"max",
"{",
"max",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"max",
"\n",
"}"
] | // Max returns the maximum value in the seq. | [
"Max",
"returns",
"the",
"maximum",
"value",
"in",
"the",
"seq",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L110-L123 |
147,465 | wcharczuk/go-chart | seq/seq.go | MinMax | func (s Seq) MinMax() (min, max float64) {
if s.Len() == 0 {
return
}
min = s.GetValue(0)
max = min
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value < min {
min = value
}
if value > max {
max = value
}
}
return
} | go | func (s Seq) MinMax() (min, max float64) {
if s.Len() == 0 {
return
}
min = s.GetValue(0)
max = min
var value float64
for i := 1; i < s.Len(); i++ {
value = s.GetValue(i)
if value < min {
min = value
}
if value > max {
max = value
}
}
return
} | [
"func",
"(",
"s",
"Seq",
")",
"MinMax",
"(",
")",
"(",
"min",
",",
"max",
"float64",
")",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"min",
"=",
"s",
".",
"GetValue",
"(",
"0",
")",
"\n",
"max",
"=",
"min",
"\n",
"var",
"value",
"float64",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"value",
"=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"if",
"value",
"<",
"min",
"{",
"min",
"=",
"value",
"\n",
"}",
"\n",
"if",
"value",
">",
"max",
"{",
"max",
"=",
"value",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // MinMax returns the minimum and the maximum in one pass. | [
"MinMax",
"returns",
"the",
"minimum",
"and",
"the",
"maximum",
"in",
"one",
"pass",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L126-L143 |
147,466 | wcharczuk/go-chart | seq/seq.go | Sort | func (s Seq) Sort() Seq {
if s.Len() == 0 {
return s
}
values := s.Array()
sort.Float64s(values)
return Seq{Provider: Array(values)}
} | go | func (s Seq) Sort() Seq {
if s.Len() == 0 {
return s
}
values := s.Array()
sort.Float64s(values)
return Seq{Provider: Array(values)}
} | [
"func",
"(",
"s",
"Seq",
")",
"Sort",
"(",
")",
"Seq",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"s",
"\n",
"}",
"\n",
"values",
":=",
"s",
".",
"Array",
"(",
")",
"\n",
"sort",
".",
"Float64s",
"(",
"values",
")",
"\n",
"return",
"Seq",
"{",
"Provider",
":",
"Array",
"(",
"values",
")",
"}",
"\n",
"}"
] | // Sort returns the seq sorted in ascending order.
// This fully enumerates the seq. | [
"Sort",
"returns",
"the",
"seq",
"sorted",
"in",
"ascending",
"order",
".",
"This",
"fully",
"enumerates",
"the",
"seq",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L147-L154 |
147,467 | wcharczuk/go-chart | seq/seq.go | Median | func (s Seq) Median() (median float64) {
l := s.Len()
if l == 0 {
return
}
sorted := s.Sort()
if l%2 == 0 {
v0 := sorted.GetValue(l/2 - 1)
v1 := sorted.GetValue(l/2 + 1)
median = (v0 + v1) / 2
} else {
median = float64(sorted.GetValue(l << 1))
}
return
} | go | func (s Seq) Median() (median float64) {
l := s.Len()
if l == 0 {
return
}
sorted := s.Sort()
if l%2 == 0 {
v0 := sorted.GetValue(l/2 - 1)
v1 := sorted.GetValue(l/2 + 1)
median = (v0 + v1) / 2
} else {
median = float64(sorted.GetValue(l << 1))
}
return
} | [
"func",
"(",
"s",
"Seq",
")",
"Median",
"(",
")",
"(",
"median",
"float64",
")",
"{",
"l",
":=",
"s",
".",
"Len",
"(",
")",
"\n",
"if",
"l",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"sorted",
":=",
"s",
".",
"Sort",
"(",
")",
"\n",
"if",
"l",
"%",
"2",
"==",
"0",
"{",
"v0",
":=",
"sorted",
".",
"GetValue",
"(",
"l",
"/",
"2",
"-",
"1",
")",
"\n",
"v1",
":=",
"sorted",
".",
"GetValue",
"(",
"l",
"/",
"2",
"+",
"1",
")",
"\n",
"median",
"=",
"(",
"v0",
"+",
"v1",
")",
"/",
"2",
"\n",
"}",
"else",
"{",
"median",
"=",
"float64",
"(",
"sorted",
".",
"GetValue",
"(",
"l",
"<<",
"1",
")",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // Median returns the median or middle value in the sorted seq. | [
"Median",
"returns",
"the",
"median",
"or",
"middle",
"value",
"in",
"the",
"sorted",
"seq",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L157-L173 |
147,468 | wcharczuk/go-chart | seq/seq.go | Sum | func (s Seq) Sum() (accum float64) {
if s.Len() == 0 {
return 0
}
for i := 0; i < s.Len(); i++ {
accum += s.GetValue(i)
}
return
} | go | func (s Seq) Sum() (accum float64) {
if s.Len() == 0 {
return 0
}
for i := 0; i < s.Len(); i++ {
accum += s.GetValue(i)
}
return
} | [
"func",
"(",
"s",
"Seq",
")",
"Sum",
"(",
")",
"(",
"accum",
"float64",
")",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"accum",
"+=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // Sum adds all the elements of a series together. | [
"Sum",
"adds",
"all",
"the",
"elements",
"of",
"a",
"series",
"together",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L176-L185 |
147,469 | wcharczuk/go-chart | seq/seq.go | Average | func (s Seq) Average() float64 {
if s.Len() == 0 {
return 0
}
return s.Sum() / float64(s.Len())
} | go | func (s Seq) Average() float64 {
if s.Len() == 0 {
return 0
}
return s.Sum() / float64(s.Len())
} | [
"func",
"(",
"s",
"Seq",
")",
"Average",
"(",
")",
"float64",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"return",
"s",
".",
"Sum",
"(",
")",
"/",
"float64",
"(",
"s",
".",
"Len",
"(",
")",
")",
"\n",
"}"
] | // Average returns the float average of the values in the buffer. | [
"Average",
"returns",
"the",
"float",
"average",
"of",
"the",
"values",
"in",
"the",
"buffer",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L188-L194 |
147,470 | wcharczuk/go-chart | seq/seq.go | Variance | func (s Seq) Variance() float64 {
if s.Len() == 0 {
return 0
}
m := s.Average()
var variance, v float64
for i := 0; i < s.Len(); i++ {
v = s.GetValue(i)
variance += (v - m) * (v - m)
}
return variance / float64(s.Len())
} | go | func (s Seq) Variance() float64 {
if s.Len() == 0 {
return 0
}
m := s.Average()
var variance, v float64
for i := 0; i < s.Len(); i++ {
v = s.GetValue(i)
variance += (v - m) * (v - m)
}
return variance / float64(s.Len())
} | [
"func",
"(",
"s",
"Seq",
")",
"Variance",
"(",
")",
"float64",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"m",
":=",
"s",
".",
"Average",
"(",
")",
"\n",
"var",
"variance",
",",
"v",
"float64",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"s",
".",
"Len",
"(",
")",
";",
"i",
"++",
"{",
"v",
"=",
"s",
".",
"GetValue",
"(",
"i",
")",
"\n",
"variance",
"+=",
"(",
"v",
"-",
"m",
")",
"*",
"(",
"v",
"-",
"m",
")",
"\n",
"}",
"\n\n",
"return",
"variance",
"/",
"float64",
"(",
"s",
".",
"Len",
"(",
")",
")",
"\n",
"}"
] | // Variance computes the variance of the buffer. | [
"Variance",
"computes",
"the",
"variance",
"of",
"the",
"buffer",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L197-L210 |
147,471 | wcharczuk/go-chart | seq/seq.go | StdDev | func (s Seq) StdDev() float64 {
if s.Len() == 0 {
return 0
}
return math.Pow(s.Variance(), 0.5)
} | go | func (s Seq) StdDev() float64 {
if s.Len() == 0 {
return 0
}
return math.Pow(s.Variance(), 0.5)
} | [
"func",
"(",
"s",
"Seq",
")",
"StdDev",
"(",
")",
"float64",
"{",
"if",
"s",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"return",
"math",
".",
"Pow",
"(",
"s",
".",
"Variance",
"(",
")",
",",
"0.5",
")",
"\n",
"}"
] | // StdDev returns the standard deviation. | [
"StdDev",
"returns",
"the",
"standard",
"deviation",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L213-L219 |
147,472 | wcharczuk/go-chart | seq/seq.go | Percentile | func (s Seq) Percentile(percent float64) (percentile float64) {
l := s.Len()
if l == 0 {
return 0
}
if percent < 0 || percent > 1.0 {
panic("percent out of range [0.0, 1.0)")
}
sorted := s.Sort()
index := percent * float64(l)
if index == float64(int64(index)) {
i := f64i(index)
ci := sorted.GetValue(i - 1)
c := sorted.GetValue(i)
percentile = (ci + c) / 2.0
} else {
i := f64i(index)
percentile = sorted.GetValue(i)
}
return percentile
} | go | func (s Seq) Percentile(percent float64) (percentile float64) {
l := s.Len()
if l == 0 {
return 0
}
if percent < 0 || percent > 1.0 {
panic("percent out of range [0.0, 1.0)")
}
sorted := s.Sort()
index := percent * float64(l)
if index == float64(int64(index)) {
i := f64i(index)
ci := sorted.GetValue(i - 1)
c := sorted.GetValue(i)
percentile = (ci + c) / 2.0
} else {
i := f64i(index)
percentile = sorted.GetValue(i)
}
return percentile
} | [
"func",
"(",
"s",
"Seq",
")",
"Percentile",
"(",
"percent",
"float64",
")",
"(",
"percentile",
"float64",
")",
"{",
"l",
":=",
"s",
".",
"Len",
"(",
")",
"\n",
"if",
"l",
"==",
"0",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"if",
"percent",
"<",
"0",
"||",
"percent",
">",
"1.0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sorted",
":=",
"s",
".",
"Sort",
"(",
")",
"\n",
"index",
":=",
"percent",
"*",
"float64",
"(",
"l",
")",
"\n",
"if",
"index",
"==",
"float64",
"(",
"int64",
"(",
"index",
")",
")",
"{",
"i",
":=",
"f64i",
"(",
"index",
")",
"\n",
"ci",
":=",
"sorted",
".",
"GetValue",
"(",
"i",
"-",
"1",
")",
"\n",
"c",
":=",
"sorted",
".",
"GetValue",
"(",
"i",
")",
"\n",
"percentile",
"=",
"(",
"ci",
"+",
"c",
")",
"/",
"2.0",
"\n",
"}",
"else",
"{",
"i",
":=",
"f64i",
"(",
"index",
")",
"\n",
"percentile",
"=",
"sorted",
".",
"GetValue",
"(",
"i",
")",
"\n",
"}",
"\n\n",
"return",
"percentile",
"\n",
"}"
] | //Percentile finds the relative standing in a slice of floats.
// `percent` should be given on the interval [0,1.0). | [
"Percentile",
"finds",
"the",
"relative",
"standing",
"in",
"a",
"slice",
"of",
"floats",
".",
"percent",
"should",
"be",
"given",
"on",
"the",
"interval",
"[",
"0",
"1",
".",
"0",
")",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/seq/seq.go#L223-L246 |
147,473 | wcharczuk/go-chart | polynomial_regression_series.go | GetValues | func (prs *PolynomialRegressionSeries) GetValues(index int) (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
offset := prs.GetOffset()
effectiveIndex := util.Math.MinInt(index+offset, prs.InnerSeries.Len())
x, y = prs.InnerSeries.GetValues(effectiveIndex)
y = prs.apply(x)
return
} | go | func (prs *PolynomialRegressionSeries) GetValues(index int) (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
offset := prs.GetOffset()
effectiveIndex := util.Math.MinInt(index+offset, prs.InnerSeries.Len())
x, y = prs.InnerSeries.GetValues(effectiveIndex)
y = prs.apply(x)
return
} | [
"func",
"(",
"prs",
"*",
"PolynomialRegressionSeries",
")",
"GetValues",
"(",
"index",
"int",
")",
"(",
"x",
",",
"y",
"float64",
")",
"{",
"if",
"prs",
".",
"InnerSeries",
"==",
"nil",
"||",
"prs",
".",
"InnerSeries",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n\n",
"if",
"prs",
".",
"coeffs",
"==",
"nil",
"{",
"coeffs",
",",
"err",
":=",
"prs",
".",
"computeCoefficients",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"prs",
".",
"coeffs",
"=",
"coeffs",
"\n",
"}",
"\n\n",
"offset",
":=",
"prs",
".",
"GetOffset",
"(",
")",
"\n",
"effectiveIndex",
":=",
"util",
".",
"Math",
".",
"MinInt",
"(",
"index",
"+",
"offset",
",",
"prs",
".",
"InnerSeries",
".",
"Len",
"(",
")",
")",
"\n",
"x",
",",
"y",
"=",
"prs",
".",
"InnerSeries",
".",
"GetValues",
"(",
"effectiveIndex",
")",
"\n",
"y",
"=",
"prs",
".",
"apply",
"(",
"x",
")",
"\n",
"return",
"\n",
"}"
] | // GetValues returns the series value for a given index. | [
"GetValues",
"returns",
"the",
"series",
"value",
"for",
"a",
"given",
"index",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/polynomial_regression_series.go#L91-L109 |
147,474 | wcharczuk/go-chart | polynomial_regression_series.go | GetFirstValues | func (prs *PolynomialRegressionSeries) GetFirstValues() (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
x, y = prs.InnerSeries.GetValues(0)
y = prs.apply(x)
return
} | go | func (prs *PolynomialRegressionSeries) GetFirstValues() (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
x, y = prs.InnerSeries.GetValues(0)
y = prs.apply(x)
return
} | [
"func",
"(",
"prs",
"*",
"PolynomialRegressionSeries",
")",
"GetFirstValues",
"(",
")",
"(",
"x",
",",
"y",
"float64",
")",
"{",
"if",
"prs",
".",
"InnerSeries",
"==",
"nil",
"||",
"prs",
".",
"InnerSeries",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"if",
"prs",
".",
"coeffs",
"==",
"nil",
"{",
"coeffs",
",",
"err",
":=",
"prs",
".",
"computeCoefficients",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"prs",
".",
"coeffs",
"=",
"coeffs",
"\n",
"}",
"\n",
"x",
",",
"y",
"=",
"prs",
".",
"InnerSeries",
".",
"GetValues",
"(",
"0",
")",
"\n",
"y",
"=",
"prs",
".",
"apply",
"(",
"x",
")",
"\n",
"return",
"\n",
"}"
] | // GetFirstValues computes the first poly regression value. | [
"GetFirstValues",
"computes",
"the",
"first",
"poly",
"regression",
"value",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/polynomial_regression_series.go#L112-L126 |
147,475 | wcharczuk/go-chart | polynomial_regression_series.go | GetLastValues | func (prs *PolynomialRegressionSeries) GetLastValues() (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
endIndex := prs.GetEndIndex()
x, y = prs.InnerSeries.GetValues(endIndex)
y = prs.apply(x)
return
} | go | func (prs *PolynomialRegressionSeries) GetLastValues() (x, y float64) {
if prs.InnerSeries == nil || prs.InnerSeries.Len() == 0 {
return
}
if prs.coeffs == nil {
coeffs, err := prs.computeCoefficients()
if err != nil {
panic(err)
}
prs.coeffs = coeffs
}
endIndex := prs.GetEndIndex()
x, y = prs.InnerSeries.GetValues(endIndex)
y = prs.apply(x)
return
} | [
"func",
"(",
"prs",
"*",
"PolynomialRegressionSeries",
")",
"GetLastValues",
"(",
")",
"(",
"x",
",",
"y",
"float64",
")",
"{",
"if",
"prs",
".",
"InnerSeries",
"==",
"nil",
"||",
"prs",
".",
"InnerSeries",
".",
"Len",
"(",
")",
"==",
"0",
"{",
"return",
"\n",
"}",
"\n",
"if",
"prs",
".",
"coeffs",
"==",
"nil",
"{",
"coeffs",
",",
"err",
":=",
"prs",
".",
"computeCoefficients",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"prs",
".",
"coeffs",
"=",
"coeffs",
"\n",
"}",
"\n",
"endIndex",
":=",
"prs",
".",
"GetEndIndex",
"(",
")",
"\n",
"x",
",",
"y",
"=",
"prs",
".",
"InnerSeries",
".",
"GetValues",
"(",
"endIndex",
")",
"\n",
"y",
"=",
"prs",
".",
"apply",
"(",
"x",
")",
"\n",
"return",
"\n",
"}"
] | // GetLastValues computes the last poly regression value. | [
"GetLastValues",
"computes",
"the",
"last",
"poly",
"regression",
"value",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/polynomial_regression_series.go#L129-L144 |
147,476 | wcharczuk/go-chart | jet.go | Jet | func Jet(v, vmin, vmax float64) drawing.Color {
c := drawing.Color{R: 0xff, G: 0xff, B: 0xff, A: 0xff} // white
var dv float64
if v < vmin {
v = vmin
}
if v > vmax {
v = vmax
}
dv = vmax - vmin
if v < (vmin + 0.25*dv) {
c.R = 0
c.G = drawing.ColorChannelFromFloat(4 * (v - vmin) / dv)
} else if v < (vmin + 0.5*dv) {
c.R = 0
c.B = drawing.ColorChannelFromFloat(1 + 4*(vmin+0.25*dv-v)/dv)
} else if v < (vmin + 0.75*dv) {
c.R = drawing.ColorChannelFromFloat(4 * (v - vmin - 0.5*dv) / dv)
c.B = 0
} else {
c.G = drawing.ColorChannelFromFloat(1 + 4*(vmin+0.75*dv-v)/dv)
c.B = 0
}
return c
} | go | func Jet(v, vmin, vmax float64) drawing.Color {
c := drawing.Color{R: 0xff, G: 0xff, B: 0xff, A: 0xff} // white
var dv float64
if v < vmin {
v = vmin
}
if v > vmax {
v = vmax
}
dv = vmax - vmin
if v < (vmin + 0.25*dv) {
c.R = 0
c.G = drawing.ColorChannelFromFloat(4 * (v - vmin) / dv)
} else if v < (vmin + 0.5*dv) {
c.R = 0
c.B = drawing.ColorChannelFromFloat(1 + 4*(vmin+0.25*dv-v)/dv)
} else if v < (vmin + 0.75*dv) {
c.R = drawing.ColorChannelFromFloat(4 * (v - vmin - 0.5*dv) / dv)
c.B = 0
} else {
c.G = drawing.ColorChannelFromFloat(1 + 4*(vmin+0.75*dv-v)/dv)
c.B = 0
}
return c
} | [
"func",
"Jet",
"(",
"v",
",",
"vmin",
",",
"vmax",
"float64",
")",
"drawing",
".",
"Color",
"{",
"c",
":=",
"drawing",
".",
"Color",
"{",
"R",
":",
"0xff",
",",
"G",
":",
"0xff",
",",
"B",
":",
"0xff",
",",
"A",
":",
"0xff",
"}",
"// white",
"\n",
"var",
"dv",
"float64",
"\n\n",
"if",
"v",
"<",
"vmin",
"{",
"v",
"=",
"vmin",
"\n",
"}",
"\n",
"if",
"v",
">",
"vmax",
"{",
"v",
"=",
"vmax",
"\n",
"}",
"\n",
"dv",
"=",
"vmax",
"-",
"vmin",
"\n\n",
"if",
"v",
"<",
"(",
"vmin",
"+",
"0.25",
"*",
"dv",
")",
"{",
"c",
".",
"R",
"=",
"0",
"\n",
"c",
".",
"G",
"=",
"drawing",
".",
"ColorChannelFromFloat",
"(",
"4",
"*",
"(",
"v",
"-",
"vmin",
")",
"/",
"dv",
")",
"\n",
"}",
"else",
"if",
"v",
"<",
"(",
"vmin",
"+",
"0.5",
"*",
"dv",
")",
"{",
"c",
".",
"R",
"=",
"0",
"\n",
"c",
".",
"B",
"=",
"drawing",
".",
"ColorChannelFromFloat",
"(",
"1",
"+",
"4",
"*",
"(",
"vmin",
"+",
"0.25",
"*",
"dv",
"-",
"v",
")",
"/",
"dv",
")",
"\n",
"}",
"else",
"if",
"v",
"<",
"(",
"vmin",
"+",
"0.75",
"*",
"dv",
")",
"{",
"c",
".",
"R",
"=",
"drawing",
".",
"ColorChannelFromFloat",
"(",
"4",
"*",
"(",
"v",
"-",
"vmin",
"-",
"0.5",
"*",
"dv",
")",
"/",
"dv",
")",
"\n",
"c",
".",
"B",
"=",
"0",
"\n",
"}",
"else",
"{",
"c",
".",
"G",
"=",
"drawing",
".",
"ColorChannelFromFloat",
"(",
"1",
"+",
"4",
"*",
"(",
"vmin",
"+",
"0.75",
"*",
"dv",
"-",
"v",
")",
"/",
"dv",
")",
"\n",
"c",
".",
"B",
"=",
"0",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"}"
] | // Jet is a color map provider based on matlab's jet color map. | [
"Jet",
"is",
"a",
"color",
"map",
"provider",
"based",
"on",
"matlab",
"s",
"jet",
"color",
"map",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/jet.go#L6-L33 |
147,477 | wcharczuk/go-chart | drawing/color.go | ColorFromHex | func ColorFromHex(hex string) Color {
var c Color
if len(hex) == 3 {
c.R = parseHex(string(hex[0])) * 0x11
c.G = parseHex(string(hex[1])) * 0x11
c.B = parseHex(string(hex[2])) * 0x11
} else {
c.R = parseHex(string(hex[0:2]))
c.G = parseHex(string(hex[2:4]))
c.B = parseHex(string(hex[4:6]))
}
c.A = 255
return c
} | go | func ColorFromHex(hex string) Color {
var c Color
if len(hex) == 3 {
c.R = parseHex(string(hex[0])) * 0x11
c.G = parseHex(string(hex[1])) * 0x11
c.B = parseHex(string(hex[2])) * 0x11
} else {
c.R = parseHex(string(hex[0:2]))
c.G = parseHex(string(hex[2:4]))
c.B = parseHex(string(hex[4:6]))
}
c.A = 255
return c
} | [
"func",
"ColorFromHex",
"(",
"hex",
"string",
")",
"Color",
"{",
"var",
"c",
"Color",
"\n",
"if",
"len",
"(",
"hex",
")",
"==",
"3",
"{",
"c",
".",
"R",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"0",
"]",
")",
")",
"*",
"0x11",
"\n",
"c",
".",
"G",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"1",
"]",
")",
")",
"*",
"0x11",
"\n",
"c",
".",
"B",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"2",
"]",
")",
")",
"*",
"0x11",
"\n",
"}",
"else",
"{",
"c",
".",
"R",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"0",
":",
"2",
"]",
")",
")",
"\n",
"c",
".",
"G",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"2",
":",
"4",
"]",
")",
")",
"\n",
"c",
".",
"B",
"=",
"parseHex",
"(",
"string",
"(",
"hex",
"[",
"4",
":",
"6",
"]",
")",
")",
"\n",
"}",
"\n",
"c",
".",
"A",
"=",
"255",
"\n",
"return",
"c",
"\n",
"}"
] | // ColorFromHex returns a color from a css hex code. | [
"ColorFromHex",
"returns",
"a",
"color",
"from",
"a",
"css",
"hex",
"code",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L34-L47 |
147,478 | wcharczuk/go-chart | drawing/color.go | ColorFromAlphaMixedRGBA | func ColorFromAlphaMixedRGBA(r, g, b, a uint32) Color {
fa := float64(a) / 255.0
var c Color
c.R = uint8(float64(r) / fa)
c.G = uint8(float64(g) / fa)
c.B = uint8(float64(b) / fa)
c.A = uint8(a | (a >> 8))
return c
} | go | func ColorFromAlphaMixedRGBA(r, g, b, a uint32) Color {
fa := float64(a) / 255.0
var c Color
c.R = uint8(float64(r) / fa)
c.G = uint8(float64(g) / fa)
c.B = uint8(float64(b) / fa)
c.A = uint8(a | (a >> 8))
return c
} | [
"func",
"ColorFromAlphaMixedRGBA",
"(",
"r",
",",
"g",
",",
"b",
",",
"a",
"uint32",
")",
"Color",
"{",
"fa",
":=",
"float64",
"(",
"a",
")",
"/",
"255.0",
"\n",
"var",
"c",
"Color",
"\n",
"c",
".",
"R",
"=",
"uint8",
"(",
"float64",
"(",
"r",
")",
"/",
"fa",
")",
"\n",
"c",
".",
"G",
"=",
"uint8",
"(",
"float64",
"(",
"g",
")",
"/",
"fa",
")",
"\n",
"c",
".",
"B",
"=",
"uint8",
"(",
"float64",
"(",
"b",
")",
"/",
"fa",
")",
"\n",
"c",
".",
"A",
"=",
"uint8",
"(",
"a",
"|",
"(",
"a",
">>",
"8",
")",
")",
"\n",
"return",
"c",
"\n",
"}"
] | // ColorFromAlphaMixedRGBA returns the system alpha mixed rgba values. | [
"ColorFromAlphaMixedRGBA",
"returns",
"the",
"system",
"alpha",
"mixed",
"rgba",
"values",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L50-L58 |
147,479 | wcharczuk/go-chart | drawing/color.go | RGBA | func (c Color) RGBA() (r, g, b, a uint32) {
fa := float64(c.A) / 255.0
r = uint32(float64(uint32(c.R)) * fa)
r |= r << 8
g = uint32(float64(uint32(c.G)) * fa)
g |= g << 8
b = uint32(float64(uint32(c.B)) * fa)
b |= b << 8
a = uint32(c.A)
a |= a << 8
return
} | go | func (c Color) RGBA() (r, g, b, a uint32) {
fa := float64(c.A) / 255.0
r = uint32(float64(uint32(c.R)) * fa)
r |= r << 8
g = uint32(float64(uint32(c.G)) * fa)
g |= g << 8
b = uint32(float64(uint32(c.B)) * fa)
b |= b << 8
a = uint32(c.A)
a |= a << 8
return
} | [
"func",
"(",
"c",
"Color",
")",
"RGBA",
"(",
")",
"(",
"r",
",",
"g",
",",
"b",
",",
"a",
"uint32",
")",
"{",
"fa",
":=",
"float64",
"(",
"c",
".",
"A",
")",
"/",
"255.0",
"\n",
"r",
"=",
"uint32",
"(",
"float64",
"(",
"uint32",
"(",
"c",
".",
"R",
")",
")",
"*",
"fa",
")",
"\n",
"r",
"|=",
"r",
"<<",
"8",
"\n",
"g",
"=",
"uint32",
"(",
"float64",
"(",
"uint32",
"(",
"c",
".",
"G",
")",
")",
"*",
"fa",
")",
"\n",
"g",
"|=",
"g",
"<<",
"8",
"\n",
"b",
"=",
"uint32",
"(",
"float64",
"(",
"uint32",
"(",
"c",
".",
"B",
")",
")",
"*",
"fa",
")",
"\n",
"b",
"|=",
"b",
"<<",
"8",
"\n",
"a",
"=",
"uint32",
"(",
"c",
".",
"A",
")",
"\n",
"a",
"|=",
"a",
"<<",
"8",
"\n",
"return",
"\n",
"}"
] | // RGBA returns the color as a pre-alpha mixed color set. | [
"RGBA",
"returns",
"the",
"color",
"as",
"a",
"pre",
"-",
"alpha",
"mixed",
"color",
"set",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L71-L82 |
147,480 | wcharczuk/go-chart | drawing/color.go | IsZero | func (c Color) IsZero() bool {
return c.R == 0 && c.G == 0 && c.B == 0 && c.A == 0
} | go | func (c Color) IsZero() bool {
return c.R == 0 && c.G == 0 && c.B == 0 && c.A == 0
} | [
"func",
"(",
"c",
"Color",
")",
"IsZero",
"(",
")",
"bool",
"{",
"return",
"c",
".",
"R",
"==",
"0",
"&&",
"c",
".",
"G",
"==",
"0",
"&&",
"c",
".",
"B",
"==",
"0",
"&&",
"c",
".",
"A",
"==",
"0",
"\n",
"}"
] | // IsZero returns if the color has been set or not. | [
"IsZero",
"returns",
"if",
"the",
"color",
"has",
"been",
"set",
"or",
"not",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L85-L87 |
147,481 | wcharczuk/go-chart | drawing/color.go | WithAlpha | func (c Color) WithAlpha(a uint8) Color {
return Color{
R: c.R,
G: c.G,
B: c.B,
A: a,
}
} | go | func (c Color) WithAlpha(a uint8) Color {
return Color{
R: c.R,
G: c.G,
B: c.B,
A: a,
}
} | [
"func",
"(",
"c",
"Color",
")",
"WithAlpha",
"(",
"a",
"uint8",
")",
"Color",
"{",
"return",
"Color",
"{",
"R",
":",
"c",
".",
"R",
",",
"G",
":",
"c",
".",
"G",
",",
"B",
":",
"c",
".",
"B",
",",
"A",
":",
"a",
",",
"}",
"\n",
"}"
] | // WithAlpha returns a copy of the color with a given alpha. | [
"WithAlpha",
"returns",
"a",
"copy",
"of",
"the",
"color",
"with",
"a",
"given",
"alpha",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L95-L102 |
147,482 | wcharczuk/go-chart | drawing/color.go | Equals | func (c Color) Equals(other Color) bool {
return c.R == other.R &&
c.G == other.G &&
c.B == other.B &&
c.A == other.A
} | go | func (c Color) Equals(other Color) bool {
return c.R == other.R &&
c.G == other.G &&
c.B == other.B &&
c.A == other.A
} | [
"func",
"(",
"c",
"Color",
")",
"Equals",
"(",
"other",
"Color",
")",
"bool",
"{",
"return",
"c",
".",
"R",
"==",
"other",
".",
"R",
"&&",
"c",
".",
"G",
"==",
"other",
".",
"G",
"&&",
"c",
".",
"B",
"==",
"other",
".",
"B",
"&&",
"c",
".",
"A",
"==",
"other",
".",
"A",
"\n",
"}"
] | // Equals returns true if the color equals another. | [
"Equals",
"returns",
"true",
"if",
"the",
"color",
"equals",
"another",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L105-L110 |
147,483 | wcharczuk/go-chart | drawing/color.go | AverageWith | func (c Color) AverageWith(other Color) Color {
return Color{
R: (c.R + other.R) >> 1,
G: (c.G + other.G) >> 1,
B: (c.B + other.B) >> 1,
A: c.A,
}
} | go | func (c Color) AverageWith(other Color) Color {
return Color{
R: (c.R + other.R) >> 1,
G: (c.G + other.G) >> 1,
B: (c.B + other.B) >> 1,
A: c.A,
}
} | [
"func",
"(",
"c",
"Color",
")",
"AverageWith",
"(",
"other",
"Color",
")",
"Color",
"{",
"return",
"Color",
"{",
"R",
":",
"(",
"c",
".",
"R",
"+",
"other",
".",
"R",
")",
">>",
"1",
",",
"G",
":",
"(",
"c",
".",
"G",
"+",
"other",
".",
"G",
")",
">>",
"1",
",",
"B",
":",
"(",
"c",
".",
"B",
"+",
"other",
".",
"B",
")",
">>",
"1",
",",
"A",
":",
"c",
".",
"A",
",",
"}",
"\n",
"}"
] | // AverageWith averages two colors. | [
"AverageWith",
"averages",
"two",
"colors",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L113-L120 |
147,484 | wcharczuk/go-chart | drawing/color.go | String | func (c Color) String() string {
fa := float64(c.A) / float64(255)
return fmt.Sprintf("rgba(%v,%v,%v,%.1f)", c.R, c.G, c.B, fa)
} | go | func (c Color) String() string {
fa := float64(c.A) / float64(255)
return fmt.Sprintf("rgba(%v,%v,%v,%.1f)", c.R, c.G, c.B, fa)
} | [
"func",
"(",
"c",
"Color",
")",
"String",
"(",
")",
"string",
"{",
"fa",
":=",
"float64",
"(",
"c",
".",
"A",
")",
"/",
"float64",
"(",
"255",
")",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"R",
",",
"c",
".",
"G",
",",
"c",
".",
"B",
",",
"fa",
")",
"\n",
"}"
] | // String returns a css string representation of the color. | [
"String",
"returns",
"a",
"css",
"string",
"representation",
"of",
"the",
"color",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/color.go#L123-L126 |
147,485 | wcharczuk/go-chart | annotation_series.go | Measure | func (as AnnotationSeries) Measure(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) Box {
box := Box{
Top: math.MaxInt32,
Left: math.MaxInt32,
Right: 0,
Bottom: 0,
}
if as.Style.IsZero() || as.Style.Show {
seriesStyle := as.Style.InheritFrom(as.annotationStyleDefaults(defaults))
for _, a := range as.Annotations {
style := a.Style.InheritFrom(seriesStyle)
lx := canvasBox.Left + xrange.Translate(a.XValue)
ly := canvasBox.Bottom - yrange.Translate(a.YValue)
ab := Draw.MeasureAnnotation(r, canvasBox, style, lx, ly, a.Label)
box.Top = util.Math.MinInt(box.Top, ab.Top)
box.Left = util.Math.MinInt(box.Left, ab.Left)
box.Right = util.Math.MaxInt(box.Right, ab.Right)
box.Bottom = util.Math.MaxInt(box.Bottom, ab.Bottom)
}
}
return box
} | go | func (as AnnotationSeries) Measure(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) Box {
box := Box{
Top: math.MaxInt32,
Left: math.MaxInt32,
Right: 0,
Bottom: 0,
}
if as.Style.IsZero() || as.Style.Show {
seriesStyle := as.Style.InheritFrom(as.annotationStyleDefaults(defaults))
for _, a := range as.Annotations {
style := a.Style.InheritFrom(seriesStyle)
lx := canvasBox.Left + xrange.Translate(a.XValue)
ly := canvasBox.Bottom - yrange.Translate(a.YValue)
ab := Draw.MeasureAnnotation(r, canvasBox, style, lx, ly, a.Label)
box.Top = util.Math.MinInt(box.Top, ab.Top)
box.Left = util.Math.MinInt(box.Left, ab.Left)
box.Right = util.Math.MaxInt(box.Right, ab.Right)
box.Bottom = util.Math.MaxInt(box.Bottom, ab.Bottom)
}
}
return box
} | [
"func",
"(",
"as",
"AnnotationSeries",
")",
"Measure",
"(",
"r",
"Renderer",
",",
"canvasBox",
"Box",
",",
"xrange",
",",
"yrange",
"Range",
",",
"defaults",
"Style",
")",
"Box",
"{",
"box",
":=",
"Box",
"{",
"Top",
":",
"math",
".",
"MaxInt32",
",",
"Left",
":",
"math",
".",
"MaxInt32",
",",
"Right",
":",
"0",
",",
"Bottom",
":",
"0",
",",
"}",
"\n",
"if",
"as",
".",
"Style",
".",
"IsZero",
"(",
")",
"||",
"as",
".",
"Style",
".",
"Show",
"{",
"seriesStyle",
":=",
"as",
".",
"Style",
".",
"InheritFrom",
"(",
"as",
".",
"annotationStyleDefaults",
"(",
"defaults",
")",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"as",
".",
"Annotations",
"{",
"style",
":=",
"a",
".",
"Style",
".",
"InheritFrom",
"(",
"seriesStyle",
")",
"\n",
"lx",
":=",
"canvasBox",
".",
"Left",
"+",
"xrange",
".",
"Translate",
"(",
"a",
".",
"XValue",
")",
"\n",
"ly",
":=",
"canvasBox",
".",
"Bottom",
"-",
"yrange",
".",
"Translate",
"(",
"a",
".",
"YValue",
")",
"\n",
"ab",
":=",
"Draw",
".",
"MeasureAnnotation",
"(",
"r",
",",
"canvasBox",
",",
"style",
",",
"lx",
",",
"ly",
",",
"a",
".",
"Label",
")",
"\n",
"box",
".",
"Top",
"=",
"util",
".",
"Math",
".",
"MinInt",
"(",
"box",
".",
"Top",
",",
"ab",
".",
"Top",
")",
"\n",
"box",
".",
"Left",
"=",
"util",
".",
"Math",
".",
"MinInt",
"(",
"box",
".",
"Left",
",",
"ab",
".",
"Left",
")",
"\n",
"box",
".",
"Right",
"=",
"util",
".",
"Math",
".",
"MaxInt",
"(",
"box",
".",
"Right",
",",
"ab",
".",
"Right",
")",
"\n",
"box",
".",
"Bottom",
"=",
"util",
".",
"Math",
".",
"MaxInt",
"(",
"box",
".",
"Bottom",
",",
"ab",
".",
"Bottom",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"box",
"\n",
"}"
] | // Measure returns a bounds box of the series. | [
"Measure",
"returns",
"a",
"bounds",
"box",
"of",
"the",
"series",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/annotation_series.go#L51-L72 |
147,486 | wcharczuk/go-chart | annotation_series.go | Render | func (as AnnotationSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) {
if as.Style.IsZero() || as.Style.Show {
seriesStyle := as.Style.InheritFrom(as.annotationStyleDefaults(defaults))
for _, a := range as.Annotations {
style := a.Style.InheritFrom(seriesStyle)
lx := canvasBox.Left + xrange.Translate(a.XValue)
ly := canvasBox.Bottom - yrange.Translate(a.YValue)
Draw.Annotation(r, canvasBox, style, lx, ly, a.Label)
}
}
} | go | func (as AnnotationSeries) Render(r Renderer, canvasBox Box, xrange, yrange Range, defaults Style) {
if as.Style.IsZero() || as.Style.Show {
seriesStyle := as.Style.InheritFrom(as.annotationStyleDefaults(defaults))
for _, a := range as.Annotations {
style := a.Style.InheritFrom(seriesStyle)
lx := canvasBox.Left + xrange.Translate(a.XValue)
ly := canvasBox.Bottom - yrange.Translate(a.YValue)
Draw.Annotation(r, canvasBox, style, lx, ly, a.Label)
}
}
} | [
"func",
"(",
"as",
"AnnotationSeries",
")",
"Render",
"(",
"r",
"Renderer",
",",
"canvasBox",
"Box",
",",
"xrange",
",",
"yrange",
"Range",
",",
"defaults",
"Style",
")",
"{",
"if",
"as",
".",
"Style",
".",
"IsZero",
"(",
")",
"||",
"as",
".",
"Style",
".",
"Show",
"{",
"seriesStyle",
":=",
"as",
".",
"Style",
".",
"InheritFrom",
"(",
"as",
".",
"annotationStyleDefaults",
"(",
"defaults",
")",
")",
"\n",
"for",
"_",
",",
"a",
":=",
"range",
"as",
".",
"Annotations",
"{",
"style",
":=",
"a",
".",
"Style",
".",
"InheritFrom",
"(",
"seriesStyle",
")",
"\n",
"lx",
":=",
"canvasBox",
".",
"Left",
"+",
"xrange",
".",
"Translate",
"(",
"a",
".",
"XValue",
")",
"\n",
"ly",
":=",
"canvasBox",
".",
"Bottom",
"-",
"yrange",
".",
"Translate",
"(",
"a",
".",
"YValue",
")",
"\n",
"Draw",
".",
"Annotation",
"(",
"r",
",",
"canvasBox",
",",
"style",
",",
"lx",
",",
"ly",
",",
"a",
".",
"Label",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // Render draws the series. | [
"Render",
"draws",
"the",
"series",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/annotation_series.go#L75-L85 |
147,487 | wcharczuk/go-chart | drawing/line.go | PolylineBresenham | func PolylineBresenham(img draw.Image, c color.Color, s ...float64) {
for i := 2; i < len(s); i += 2 {
Bresenham(img, c, int(s[i-2]+0.5), int(s[i-1]+0.5), int(s[i]+0.5), int(s[i+1]+0.5))
}
} | go | func PolylineBresenham(img draw.Image, c color.Color, s ...float64) {
for i := 2; i < len(s); i += 2 {
Bresenham(img, c, int(s[i-2]+0.5), int(s[i-1]+0.5), int(s[i]+0.5), int(s[i+1]+0.5))
}
} | [
"func",
"PolylineBresenham",
"(",
"img",
"draw",
".",
"Image",
",",
"c",
"color",
".",
"Color",
",",
"s",
"...",
"float64",
")",
"{",
"for",
"i",
":=",
"2",
";",
"i",
"<",
"len",
"(",
"s",
")",
";",
"i",
"+=",
"2",
"{",
"Bresenham",
"(",
"img",
",",
"c",
",",
"int",
"(",
"s",
"[",
"i",
"-",
"2",
"]",
"+",
"0.5",
")",
",",
"int",
"(",
"s",
"[",
"i",
"-",
"1",
"]",
"+",
"0.5",
")",
",",
"int",
"(",
"s",
"[",
"i",
"]",
"+",
"0.5",
")",
",",
"int",
"(",
"s",
"[",
"i",
"+",
"1",
"]",
"+",
"0.5",
")",
")",
"\n",
"}",
"\n",
"}"
] | // PolylineBresenham draws a polyline to an image | [
"PolylineBresenham",
"draws",
"a",
"polyline",
"to",
"an",
"image"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/line.go#L9-L13 |
147,488 | wcharczuk/go-chart | drawing/matrix.go | Transform | func (tr Matrix) Transform(points []float64) {
for i, j := 0, 1; j < len(points); i, j = i+2, j+2 {
x := points[i]
y := points[j]
points[i] = x*tr[0] + y*tr[2] + tr[4]
points[j] = x*tr[1] + y*tr[3] + tr[5]
}
} | go | func (tr Matrix) Transform(points []float64) {
for i, j := 0, 1; j < len(points); i, j = i+2, j+2 {
x := points[i]
y := points[j]
points[i] = x*tr[0] + y*tr[2] + tr[4]
points[j] = x*tr[1] + y*tr[3] + tr[5]
}
} | [
"func",
"(",
"tr",
"Matrix",
")",
"Transform",
"(",
"points",
"[",
"]",
"float64",
")",
"{",
"for",
"i",
",",
"j",
":=",
"0",
",",
"1",
";",
"j",
"<",
"len",
"(",
"points",
")",
";",
"i",
",",
"j",
"=",
"i",
"+",
"2",
",",
"j",
"+",
"2",
"{",
"x",
":=",
"points",
"[",
"i",
"]",
"\n",
"y",
":=",
"points",
"[",
"j",
"]",
"\n",
"points",
"[",
"i",
"]",
"=",
"x",
"*",
"tr",
"[",
"0",
"]",
"+",
"y",
"*",
"tr",
"[",
"2",
"]",
"+",
"tr",
"[",
"4",
"]",
"\n",
"points",
"[",
"j",
"]",
"=",
"x",
"*",
"tr",
"[",
"1",
"]",
"+",
"y",
"*",
"tr",
"[",
"3",
"]",
"+",
"tr",
"[",
"5",
"]",
"\n",
"}",
"\n",
"}"
] | // Transform applies the transformation matrix to points. It modify the points passed in parameter. | [
"Transform",
"applies",
"the",
"transformation",
"matrix",
"to",
"points",
".",
"It",
"modify",
"the",
"points",
"passed",
"in",
"parameter",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L20-L27 |
147,489 | wcharczuk/go-chart | drawing/matrix.go | TransformPoint | func (tr Matrix) TransformPoint(x, y float64) (xres, yres float64) {
xres = x*tr[0] + y*tr[2] + tr[4]
yres = x*tr[1] + y*tr[3] + tr[5]
return xres, yres
} | go | func (tr Matrix) TransformPoint(x, y float64) (xres, yres float64) {
xres = x*tr[0] + y*tr[2] + tr[4]
yres = x*tr[1] + y*tr[3] + tr[5]
return xres, yres
} | [
"func",
"(",
"tr",
"Matrix",
")",
"TransformPoint",
"(",
"x",
",",
"y",
"float64",
")",
"(",
"xres",
",",
"yres",
"float64",
")",
"{",
"xres",
"=",
"x",
"*",
"tr",
"[",
"0",
"]",
"+",
"y",
"*",
"tr",
"[",
"2",
"]",
"+",
"tr",
"[",
"4",
"]",
"\n",
"yres",
"=",
"x",
"*",
"tr",
"[",
"1",
"]",
"+",
"y",
"*",
"tr",
"[",
"3",
"]",
"+",
"tr",
"[",
"5",
"]",
"\n",
"return",
"xres",
",",
"yres",
"\n",
"}"
] | // TransformPoint applies the transformation matrix to point. It returns the point the transformed point. | [
"TransformPoint",
"applies",
"the",
"transformation",
"matrix",
"to",
"point",
".",
"It",
"returns",
"the",
"point",
"the",
"transformed",
"point",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L30-L34 |
147,490 | wcharczuk/go-chart | drawing/matrix.go | TransformRectangle | func (tr Matrix) TransformRectangle(x0, y0, x2, y2 float64) (nx0, ny0, nx2, ny2 float64) {
points := []float64{x0, y0, x2, y0, x2, y2, x0, y2}
tr.Transform(points)
points[0], points[2] = minMax(points[0], points[2])
points[4], points[6] = minMax(points[4], points[6])
points[1], points[3] = minMax(points[1], points[3])
points[5], points[7] = minMax(points[5], points[7])
nx0 = math.Min(points[0], points[4])
ny0 = math.Min(points[1], points[5])
nx2 = math.Max(points[2], points[6])
ny2 = math.Max(points[3], points[7])
return nx0, ny0, nx2, ny2
} | go | func (tr Matrix) TransformRectangle(x0, y0, x2, y2 float64) (nx0, ny0, nx2, ny2 float64) {
points := []float64{x0, y0, x2, y0, x2, y2, x0, y2}
tr.Transform(points)
points[0], points[2] = minMax(points[0], points[2])
points[4], points[6] = minMax(points[4], points[6])
points[1], points[3] = minMax(points[1], points[3])
points[5], points[7] = minMax(points[5], points[7])
nx0 = math.Min(points[0], points[4])
ny0 = math.Min(points[1], points[5])
nx2 = math.Max(points[2], points[6])
ny2 = math.Max(points[3], points[7])
return nx0, ny0, nx2, ny2
} | [
"func",
"(",
"tr",
"Matrix",
")",
"TransformRectangle",
"(",
"x0",
",",
"y0",
",",
"x2",
",",
"y2",
"float64",
")",
"(",
"nx0",
",",
"ny0",
",",
"nx2",
",",
"ny2",
"float64",
")",
"{",
"points",
":=",
"[",
"]",
"float64",
"{",
"x0",
",",
"y0",
",",
"x2",
",",
"y0",
",",
"x2",
",",
"y2",
",",
"x0",
",",
"y2",
"}",
"\n",
"tr",
".",
"Transform",
"(",
"points",
")",
"\n",
"points",
"[",
"0",
"]",
",",
"points",
"[",
"2",
"]",
"=",
"minMax",
"(",
"points",
"[",
"0",
"]",
",",
"points",
"[",
"2",
"]",
")",
"\n",
"points",
"[",
"4",
"]",
",",
"points",
"[",
"6",
"]",
"=",
"minMax",
"(",
"points",
"[",
"4",
"]",
",",
"points",
"[",
"6",
"]",
")",
"\n",
"points",
"[",
"1",
"]",
",",
"points",
"[",
"3",
"]",
"=",
"minMax",
"(",
"points",
"[",
"1",
"]",
",",
"points",
"[",
"3",
"]",
")",
"\n",
"points",
"[",
"5",
"]",
",",
"points",
"[",
"7",
"]",
"=",
"minMax",
"(",
"points",
"[",
"5",
"]",
",",
"points",
"[",
"7",
"]",
")",
"\n\n",
"nx0",
"=",
"math",
".",
"Min",
"(",
"points",
"[",
"0",
"]",
",",
"points",
"[",
"4",
"]",
")",
"\n",
"ny0",
"=",
"math",
".",
"Min",
"(",
"points",
"[",
"1",
"]",
",",
"points",
"[",
"5",
"]",
")",
"\n",
"nx2",
"=",
"math",
".",
"Max",
"(",
"points",
"[",
"2",
"]",
",",
"points",
"[",
"6",
"]",
")",
"\n",
"ny2",
"=",
"math",
".",
"Max",
"(",
"points",
"[",
"3",
"]",
",",
"points",
"[",
"7",
"]",
")",
"\n",
"return",
"nx0",
",",
"ny0",
",",
"nx2",
",",
"ny2",
"\n",
"}"
] | // TransformRectangle applies the transformation matrix to the rectangle represented by the min and the max point of the rectangle | [
"TransformRectangle",
"applies",
"the",
"transformation",
"matrix",
"to",
"the",
"rectangle",
"represented",
"by",
"the",
"min",
"and",
"the",
"max",
"point",
"of",
"the",
"rectangle"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L44-L57 |
147,491 | wcharczuk/go-chart | drawing/matrix.go | InverseTransform | func (tr Matrix) InverseTransform(points []float64) {
d := tr.Determinant() // matrix determinant
for i, j := 0, 1; j < len(points); i, j = i+2, j+2 {
x := points[i]
y := points[j]
points[i] = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d
points[j] = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d
}
} | go | func (tr Matrix) InverseTransform(points []float64) {
d := tr.Determinant() // matrix determinant
for i, j := 0, 1; j < len(points); i, j = i+2, j+2 {
x := points[i]
y := points[j]
points[i] = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d
points[j] = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d
}
} | [
"func",
"(",
"tr",
"Matrix",
")",
"InverseTransform",
"(",
"points",
"[",
"]",
"float64",
")",
"{",
"d",
":=",
"tr",
".",
"Determinant",
"(",
")",
"// matrix determinant",
"\n",
"for",
"i",
",",
"j",
":=",
"0",
",",
"1",
";",
"j",
"<",
"len",
"(",
"points",
")",
";",
"i",
",",
"j",
"=",
"i",
"+",
"2",
",",
"j",
"+",
"2",
"{",
"x",
":=",
"points",
"[",
"i",
"]",
"\n",
"y",
":=",
"points",
"[",
"j",
"]",
"\n",
"points",
"[",
"i",
"]",
"=",
"(",
"(",
"x",
"-",
"tr",
"[",
"4",
"]",
")",
"*",
"tr",
"[",
"3",
"]",
"-",
"(",
"y",
"-",
"tr",
"[",
"5",
"]",
")",
"*",
"tr",
"[",
"2",
"]",
")",
"/",
"d",
"\n",
"points",
"[",
"j",
"]",
"=",
"(",
"(",
"y",
"-",
"tr",
"[",
"5",
"]",
")",
"*",
"tr",
"[",
"0",
"]",
"-",
"(",
"x",
"-",
"tr",
"[",
"4",
"]",
")",
"*",
"tr",
"[",
"1",
"]",
")",
"/",
"d",
"\n",
"}",
"\n",
"}"
] | // InverseTransform applies the transformation inverse matrix to the rectangle represented by the min and the max point of the rectangle | [
"InverseTransform",
"applies",
"the",
"transformation",
"inverse",
"matrix",
"to",
"the",
"rectangle",
"represented",
"by",
"the",
"min",
"and",
"the",
"max",
"point",
"of",
"the",
"rectangle"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L60-L68 |
147,492 | wcharczuk/go-chart | drawing/matrix.go | InverseTransformPoint | func (tr Matrix) InverseTransformPoint(x, y float64) (xres, yres float64) {
d := tr.Determinant() // matrix determinant
xres = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d
yres = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d
return xres, yres
} | go | func (tr Matrix) InverseTransformPoint(x, y float64) (xres, yres float64) {
d := tr.Determinant() // matrix determinant
xres = ((x-tr[4])*tr[3] - (y-tr[5])*tr[2]) / d
yres = ((y-tr[5])*tr[0] - (x-tr[4])*tr[1]) / d
return xres, yres
} | [
"func",
"(",
"tr",
"Matrix",
")",
"InverseTransformPoint",
"(",
"x",
",",
"y",
"float64",
")",
"(",
"xres",
",",
"yres",
"float64",
")",
"{",
"d",
":=",
"tr",
".",
"Determinant",
"(",
")",
"// matrix determinant",
"\n",
"xres",
"=",
"(",
"(",
"x",
"-",
"tr",
"[",
"4",
"]",
")",
"*",
"tr",
"[",
"3",
"]",
"-",
"(",
"y",
"-",
"tr",
"[",
"5",
"]",
")",
"*",
"tr",
"[",
"2",
"]",
")",
"/",
"d",
"\n",
"yres",
"=",
"(",
"(",
"y",
"-",
"tr",
"[",
"5",
"]",
")",
"*",
"tr",
"[",
"0",
"]",
"-",
"(",
"x",
"-",
"tr",
"[",
"4",
"]",
")",
"*",
"tr",
"[",
"1",
"]",
")",
"/",
"d",
"\n",
"return",
"xres",
",",
"yres",
"\n",
"}"
] | // InverseTransformPoint applies the transformation inverse matrix to point. It returns the point the transformed point. | [
"InverseTransformPoint",
"applies",
"the",
"transformation",
"inverse",
"matrix",
"to",
"point",
".",
"It",
"returns",
"the",
"point",
"the",
"transformed",
"point",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L71-L76 |
147,493 | wcharczuk/go-chart | drawing/matrix.go | NewRotationMatrix | func NewRotationMatrix(angle float64) Matrix {
c := math.Cos(angle)
s := math.Sin(angle)
return Matrix{c, s, -s, c, 0, 0}
} | go | func NewRotationMatrix(angle float64) Matrix {
c := math.Cos(angle)
s := math.Sin(angle)
return Matrix{c, s, -s, c, 0, 0}
} | [
"func",
"NewRotationMatrix",
"(",
"angle",
"float64",
")",
"Matrix",
"{",
"c",
":=",
"math",
".",
"Cos",
"(",
"angle",
")",
"\n",
"s",
":=",
"math",
".",
"Sin",
"(",
"angle",
")",
"\n",
"return",
"Matrix",
"{",
"c",
",",
"s",
",",
"-",
"s",
",",
"c",
",",
"0",
",",
"0",
"}",
"\n",
"}"
] | // NewRotationMatrix creates a rotation transformation matrix. angle is in radian | [
"NewRotationMatrix",
"creates",
"a",
"rotation",
"transformation",
"matrix",
".",
"angle",
"is",
"in",
"radian"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L105-L109 |
147,494 | wcharczuk/go-chart | drawing/matrix.go | NewMatrixFromRects | func NewMatrixFromRects(rectangle1, rectangle2 [4]float64) Matrix {
xScale := (rectangle2[2] - rectangle2[0]) / (rectangle1[2] - rectangle1[0])
yScale := (rectangle2[3] - rectangle2[1]) / (rectangle1[3] - rectangle1[1])
xOffset := rectangle2[0] - (rectangle1[0] * xScale)
yOffset := rectangle2[1] - (rectangle1[1] * yScale)
return Matrix{xScale, 0, 0, yScale, xOffset, yOffset}
} | go | func NewMatrixFromRects(rectangle1, rectangle2 [4]float64) Matrix {
xScale := (rectangle2[2] - rectangle2[0]) / (rectangle1[2] - rectangle1[0])
yScale := (rectangle2[3] - rectangle2[1]) / (rectangle1[3] - rectangle1[1])
xOffset := rectangle2[0] - (rectangle1[0] * xScale)
yOffset := rectangle2[1] - (rectangle1[1] * yScale)
return Matrix{xScale, 0, 0, yScale, xOffset, yOffset}
} | [
"func",
"NewMatrixFromRects",
"(",
"rectangle1",
",",
"rectangle2",
"[",
"4",
"]",
"float64",
")",
"Matrix",
"{",
"xScale",
":=",
"(",
"rectangle2",
"[",
"2",
"]",
"-",
"rectangle2",
"[",
"0",
"]",
")",
"/",
"(",
"rectangle1",
"[",
"2",
"]",
"-",
"rectangle1",
"[",
"0",
"]",
")",
"\n",
"yScale",
":=",
"(",
"rectangle2",
"[",
"3",
"]",
"-",
"rectangle2",
"[",
"1",
"]",
")",
"/",
"(",
"rectangle1",
"[",
"3",
"]",
"-",
"rectangle1",
"[",
"1",
"]",
")",
"\n",
"xOffset",
":=",
"rectangle2",
"[",
"0",
"]",
"-",
"(",
"rectangle1",
"[",
"0",
"]",
"*",
"xScale",
")",
"\n",
"yOffset",
":=",
"rectangle2",
"[",
"1",
"]",
"-",
"(",
"rectangle1",
"[",
"1",
"]",
"*",
"yScale",
")",
"\n",
"return",
"Matrix",
"{",
"xScale",
",",
"0",
",",
"0",
",",
"yScale",
",",
"xOffset",
",",
"yOffset",
"}",
"\n",
"}"
] | // NewMatrixFromRects creates a transformation matrix, combining a scale and a translation, that transform rectangle1 into rectangle2. | [
"NewMatrixFromRects",
"creates",
"a",
"transformation",
"matrix",
"combining",
"a",
"scale",
"and",
"a",
"translation",
"that",
"transform",
"rectangle1",
"into",
"rectangle2",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L112-L118 |
147,495 | wcharczuk/go-chart | drawing/matrix.go | Inverse | func (tr *Matrix) Inverse() {
d := tr.Determinant() // matrix determinant
tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5]
tr[0] = tr3 / d
tr[1] = -tr1 / d
tr[2] = -tr2 / d
tr[3] = tr0 / d
tr[4] = (tr2*tr5 - tr3*tr4) / d
tr[5] = (tr1*tr4 - tr0*tr5) / d
} | go | func (tr *Matrix) Inverse() {
d := tr.Determinant() // matrix determinant
tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5]
tr[0] = tr3 / d
tr[1] = -tr1 / d
tr[2] = -tr2 / d
tr[3] = tr0 / d
tr[4] = (tr2*tr5 - tr3*tr4) / d
tr[5] = (tr1*tr4 - tr0*tr5) / d
} | [
"func",
"(",
"tr",
"*",
"Matrix",
")",
"Inverse",
"(",
")",
"{",
"d",
":=",
"tr",
".",
"Determinant",
"(",
")",
"// matrix determinant",
"\n",
"tr0",
",",
"tr1",
",",
"tr2",
",",
"tr3",
",",
"tr4",
",",
"tr5",
":=",
"tr",
"[",
"0",
"]",
",",
"tr",
"[",
"1",
"]",
",",
"tr",
"[",
"2",
"]",
",",
"tr",
"[",
"3",
"]",
",",
"tr",
"[",
"4",
"]",
",",
"tr",
"[",
"5",
"]",
"\n",
"tr",
"[",
"0",
"]",
"=",
"tr3",
"/",
"d",
"\n",
"tr",
"[",
"1",
"]",
"=",
"-",
"tr1",
"/",
"d",
"\n",
"tr",
"[",
"2",
"]",
"=",
"-",
"tr2",
"/",
"d",
"\n",
"tr",
"[",
"3",
"]",
"=",
"tr0",
"/",
"d",
"\n",
"tr",
"[",
"4",
"]",
"=",
"(",
"tr2",
"*",
"tr5",
"-",
"tr3",
"*",
"tr4",
")",
"/",
"d",
"\n",
"tr",
"[",
"5",
"]",
"=",
"(",
"tr1",
"*",
"tr4",
"-",
"tr0",
"*",
"tr5",
")",
"/",
"d",
"\n",
"}"
] | // Inverse computes the inverse matrix | [
"Inverse",
"computes",
"the",
"inverse",
"matrix"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L121-L130 |
147,496 | wcharczuk/go-chart | drawing/matrix.go | Copy | func (tr Matrix) Copy() Matrix {
var result Matrix
copy(result[:], tr[:])
return result
} | go | func (tr Matrix) Copy() Matrix {
var result Matrix
copy(result[:], tr[:])
return result
} | [
"func",
"(",
"tr",
"Matrix",
")",
"Copy",
"(",
")",
"Matrix",
"{",
"var",
"result",
"Matrix",
"\n",
"copy",
"(",
"result",
"[",
":",
"]",
",",
"tr",
"[",
":",
"]",
")",
"\n",
"return",
"result",
"\n",
"}"
] | // Copy copies the matrix. | [
"Copy",
"copies",
"the",
"matrix",
"."
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L133-L137 |
147,497 | wcharczuk/go-chart | drawing/matrix.go | Compose | func (tr *Matrix) Compose(trToCompose Matrix) {
tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5]
tr[0] = trToCompose[0]*tr0 + trToCompose[1]*tr2
tr[1] = trToCompose[1]*tr3 + trToCompose[0]*tr1
tr[2] = trToCompose[2]*tr0 + trToCompose[3]*tr2
tr[3] = trToCompose[3]*tr3 + trToCompose[2]*tr1
tr[4] = trToCompose[4]*tr0 + trToCompose[5]*tr2 + tr4
tr[5] = trToCompose[5]*tr3 + trToCompose[4]*tr1 + tr5
} | go | func (tr *Matrix) Compose(trToCompose Matrix) {
tr0, tr1, tr2, tr3, tr4, tr5 := tr[0], tr[1], tr[2], tr[3], tr[4], tr[5]
tr[0] = trToCompose[0]*tr0 + trToCompose[1]*tr2
tr[1] = trToCompose[1]*tr3 + trToCompose[0]*tr1
tr[2] = trToCompose[2]*tr0 + trToCompose[3]*tr2
tr[3] = trToCompose[3]*tr3 + trToCompose[2]*tr1
tr[4] = trToCompose[4]*tr0 + trToCompose[5]*tr2 + tr4
tr[5] = trToCompose[5]*tr3 + trToCompose[4]*tr1 + tr5
} | [
"func",
"(",
"tr",
"*",
"Matrix",
")",
"Compose",
"(",
"trToCompose",
"Matrix",
")",
"{",
"tr0",
",",
"tr1",
",",
"tr2",
",",
"tr3",
",",
"tr4",
",",
"tr5",
":=",
"tr",
"[",
"0",
"]",
",",
"tr",
"[",
"1",
"]",
",",
"tr",
"[",
"2",
"]",
",",
"tr",
"[",
"3",
"]",
",",
"tr",
"[",
"4",
"]",
",",
"tr",
"[",
"5",
"]",
"\n",
"tr",
"[",
"0",
"]",
"=",
"trToCompose",
"[",
"0",
"]",
"*",
"tr0",
"+",
"trToCompose",
"[",
"1",
"]",
"*",
"tr2",
"\n",
"tr",
"[",
"1",
"]",
"=",
"trToCompose",
"[",
"1",
"]",
"*",
"tr3",
"+",
"trToCompose",
"[",
"0",
"]",
"*",
"tr1",
"\n",
"tr",
"[",
"2",
"]",
"=",
"trToCompose",
"[",
"2",
"]",
"*",
"tr0",
"+",
"trToCompose",
"[",
"3",
"]",
"*",
"tr2",
"\n",
"tr",
"[",
"3",
"]",
"=",
"trToCompose",
"[",
"3",
"]",
"*",
"tr3",
"+",
"trToCompose",
"[",
"2",
"]",
"*",
"tr1",
"\n",
"tr",
"[",
"4",
"]",
"=",
"trToCompose",
"[",
"4",
"]",
"*",
"tr0",
"+",
"trToCompose",
"[",
"5",
"]",
"*",
"tr2",
"+",
"tr4",
"\n",
"tr",
"[",
"5",
"]",
"=",
"trToCompose",
"[",
"5",
"]",
"*",
"tr3",
"+",
"trToCompose",
"[",
"4",
"]",
"*",
"tr1",
"+",
"tr5",
"\n",
"}"
] | // Compose multiplies trToConcat x tr | [
"Compose",
"multiplies",
"trToConcat",
"x",
"tr"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L140-L148 |
147,498 | wcharczuk/go-chart | drawing/matrix.go | Scale | func (tr *Matrix) Scale(sx, sy float64) {
tr[0] = sx * tr[0]
tr[1] = sx * tr[1]
tr[2] = sy * tr[2]
tr[3] = sy * tr[3]
} | go | func (tr *Matrix) Scale(sx, sy float64) {
tr[0] = sx * tr[0]
tr[1] = sx * tr[1]
tr[2] = sy * tr[2]
tr[3] = sy * tr[3]
} | [
"func",
"(",
"tr",
"*",
"Matrix",
")",
"Scale",
"(",
"sx",
",",
"sy",
"float64",
")",
"{",
"tr",
"[",
"0",
"]",
"=",
"sx",
"*",
"tr",
"[",
"0",
"]",
"\n",
"tr",
"[",
"1",
"]",
"=",
"sx",
"*",
"tr",
"[",
"1",
"]",
"\n",
"tr",
"[",
"2",
"]",
"=",
"sy",
"*",
"tr",
"[",
"2",
"]",
"\n",
"tr",
"[",
"3",
"]",
"=",
"sy",
"*",
"tr",
"[",
"3",
"]",
"\n",
"}"
] | // Scale adds a scale to the matrix | [
"Scale",
"adds",
"a",
"scale",
"to",
"the",
"matrix"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L151-L156 |
147,499 | wcharczuk/go-chart | drawing/matrix.go | Translate | func (tr *Matrix) Translate(tx, ty float64) {
tr[4] = tx*tr[0] + ty*tr[2] + tr[4]
tr[5] = ty*tr[3] + tx*tr[1] + tr[5]
} | go | func (tr *Matrix) Translate(tx, ty float64) {
tr[4] = tx*tr[0] + ty*tr[2] + tr[4]
tr[5] = ty*tr[3] + tx*tr[1] + tr[5]
} | [
"func",
"(",
"tr",
"*",
"Matrix",
")",
"Translate",
"(",
"tx",
",",
"ty",
"float64",
")",
"{",
"tr",
"[",
"4",
"]",
"=",
"tx",
"*",
"tr",
"[",
"0",
"]",
"+",
"ty",
"*",
"tr",
"[",
"2",
"]",
"+",
"tr",
"[",
"4",
"]",
"\n",
"tr",
"[",
"5",
"]",
"=",
"ty",
"*",
"tr",
"[",
"3",
"]",
"+",
"tx",
"*",
"tr",
"[",
"1",
"]",
"+",
"tr",
"[",
"5",
"]",
"\n",
"}"
] | // Translate adds a translation to the matrix | [
"Translate",
"adds",
"a",
"translation",
"to",
"the",
"matrix"
] | 9852fce5a172598e72d16f4306f0f17a53d94eb4 | https://github.com/wcharczuk/go-chart/blob/9852fce5a172598e72d16f4306f0f17a53d94eb4/drawing/matrix.go#L159-L162 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.