_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q11200 | Mul | train | func (mat *T) Mul(f float32) *T {
for i, col := range mat {
for j := range col {
mat[i][j] *= f
}
}
return mat
} | go | {
"resource": ""
} |
q11201 | Muled | train | func (mat *T) Muled(f float32) T {
result := *mat
result.Mul(f)
return result
} | go | {
"resource": ""
} |
q11202 | MultMatrix | train | func (mat *T) MultMatrix(m *T) *T {
// iterate over the rows of mat
for i := range mat {
row := vec4.T{mat[0][i], mat[1][i], mat[2][i], mat[3][i]}
mat[0][i] = vec4.Dot4(&row, &m[0])
mat[1][i] = vec4.Dot4(&row, &m[1])
mat[2][i] = vec4.Dot4(&row, &m[2])
mat[3][i] = vec4.Dot4(&row, &m[3])
}
return mat
} | go | {
"resource": ""
} |
q11203 | AssignMat3x3 | train | func (mat *T) AssignMat3x3(m *mat3.T) *T {
*mat = T{
vec4.T{m[0][0], m[1][0], m[2][0], 0},
vec4.T{m[0][1], m[1][1], m[2][1], 0},
vec4.T{m[0][2], m[1][2], m[2][2], 0},
vec4.T{0, 0, 0, 1},
}
return mat
} | go | {
"resource": ""
} |
q11204 | TransformVec4 | train | func (mat *T) TransformVec4(v *vec4.T) {
// Use intermediate variables to not alter further computations.
x := mat[0][0]*v[0] + mat[1][0]*v[1] + mat[2][0]*v[2] + mat[3][0]*v[3]
y := mat[0][1]*v[0] + mat[1][1]*v[1] + mat[2][1]*v[2] + mat[3][1]*v[3]
z := mat[0][2]*v[0] + mat[1][2]*v[1] + mat[2][2]*v[2] + mat[3][2]*v[... | go | {
"resource": ""
} |
q11205 | SetTranslation | train | func (mat *T) SetTranslation(v *vec3.T) *T {
mat[3][0] = v[0]
mat[3][1] = v[1]
mat[3][2] = v[2]
return mat
} | go | {
"resource": ""
} |
q11206 | Translate | train | func (mat *T) Translate(v *vec3.T) *T {
mat[3][0] += v[0]
mat[3][1] += v[1]
mat[3][2] += v[2]
return mat
} | go | {
"resource": ""
} |
q11207 | ScaleVec3 | train | func (mat *T) ScaleVec3(s *vec3.T) *T {
mat[0][0] *= s[0]
mat[1][1] *= s[1]
mat[2][2] *= s[2]
return mat
} | go | {
"resource": ""
} |
q11208 | AssignPerspectiveProjection | train | func (mat *T) AssignPerspectiveProjection(left, right, bottom, top, znear, zfar float32) *T {
near2 := znear + znear
ooFarNear := 1 / (zfar - znear)
mat[0][0] = near2 / (right - left)
mat[1][0] = 0
mat[2][0] = (right + left) / (right - left)
mat[3][0] = 0
mat[0][1] = 0
mat[1][1] = near2 / (top - bottom)
mat[... | go | {
"resource": ""
} |
q11209 | AssignOrthogonalProjection | train | func (mat *T) AssignOrthogonalProjection(left, right, bottom, top, znear, zfar float32) *T {
ooRightLeft := 1 / (right - left)
ooTopBottom := 1 / (top - bottom)
ooFarNear := 1 / (zfar - znear)
mat[0][0] = 2 * ooRightLeft
mat[1][0] = 0
mat[2][0] = 0
mat[3][0] = -(right + left) * ooRightLeft
mat[0][1] = 0
mat[... | go | {
"resource": ""
} |
q11210 | Transpose3x3 | train | func (mat *T) Transpose3x3() *T {
swap(&mat[1][0], &mat[0][1])
swap(&mat[2][0], &mat[0][2])
swap(&mat[2][1], &mat[1][2])
return mat
} | go | {
"resource": ""
} |
q11211 | Adjugate | train | func (mat *T) Adjugate() *T {
matOrig := *mat
for i := 0; i < 4; i++ {
for j := 0; j < 4; j++ {
// - 1 for odd i+j, 1 for even i+j
sign := float32(((i+j)%2)*-2 + 1)
mat[i][j] = matOrig.maskedBlock(i, j).Determinant() * sign
}
}
return mat.Transpose()
} | go | {
"resource": ""
} |
q11212 | maskedBlock | train | func (mat *T) maskedBlock(blockI, blockJ int) *mat3.T {
var m mat3.T
m_i := 0
for i := 0; i < 4; i++ {
if i == blockI {
continue
}
m_j := 0
for j := 0; j < 4; j++ {
if j == blockJ {
continue
}
m[m_i][m_j] = mat[i][j]
m_j++
}
m_i++
}
return &m
} | go | {
"resource": ""
} |
q11213 | Invert | train | func (mat *T) Invert() *T {
initialDet := mat.Determinant()
mat.Adjugate()
mat.Mul(1 / initialDet)
return mat
} | go | {
"resource": ""
} |
q11214 | Scaled | train | func (vec *T) Scaled(f float32) T {
return T{vec[0] * f, vec[1] * f, vec[2] * f}
} | go | {
"resource": ""
} |
q11215 | Abs | train | func (vec *T) Abs() *T {
vec[0] = math.Abs(vec[0])
vec[1] = math.Abs(vec[1])
vec[2] = math.Abs(vec[2])
return vec
} | go | {
"resource": ""
} |
q11216 | Absed | train | func (vec *T) Absed() T {
return T{math.Abs(vec[0]), math.Abs(vec[1]), math.Abs(vec[2])}
} | go | {
"resource": ""
} |
q11217 | Mul | train | func (vec *T) Mul(v *T) *T {
vec[0] *= v[0]
vec[1] *= v[1]
vec[2] *= v[2]
return vec
} | go | {
"resource": ""
} |
q11218 | Mul | train | func Mul(a, b *T) T {
return T{a[0] * b[0], a[1] * b[1], a[2] * b[2]}
} | go | {
"resource": ""
} |
q11219 | Min | train | func Min(a, b *T) T {
min := *a
if b[0] < min[0] {
min[0] = b[0]
}
if b[1] < min[1] {
min[1] = b[1]
}
if b[2] < min[2] {
min[2] = b[2]
}
return min
} | go | {
"resource": ""
} |
q11220 | Max | train | func Max(a, b *T) T {
max := *a
if b[0] > max[0] {
max[0] = b[0]
}
if b[1] > max[1] {
max[1] = b[1]
}
if b[2] > max[2] {
max[2] = b[2]
}
return max
} | go | {
"resource": ""
} |
q11221 | Dot | train | func Dot(a, b *T) float64 {
return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]
} | go | {
"resource": ""
} |
q11222 | AssignZRotation | train | func (mat *T) AssignZRotation(angle float64) *T {
cosine := math.Cos(angle)
sine := math.Sin(angle)
mat[0][0] = cosine
mat[1][0] = -sine
mat[2][0] = 0
mat[3][0] = 0
mat[0][1] = sine
mat[1][1] = cosine
mat[2][1] = 0
mat[3][1] = 0
mat[0][2] = 0
mat[1][2] = 0
mat[2][2] = 1
mat[3][2] = 0
mat[0][3] = 0
m... | go | {
"resource": ""
} |
q11223 | ContainsPoint | train | func (box *Box) ContainsPoint(p *T) bool {
return p[0] >= box.Min[0] && p[0] <= box.Max[0] &&
p[1] >= box.Min[1] && p[1] <= box.Max[1] &&
p[2] >= box.Min[2] && p[2] <= box.Max[2]
} | go | {
"resource": ""
} |
q11224 | Join | train | func (box *Box) Join(other *Box) {
box.Min = Min(&box.Min, &other.Min)
box.Max = Max(&box.Max, &other.Max)
} | go | {
"resource": ""
} |
q11225 | Joined | train | func Joined(a, b *Box) Box {
var joined Box
joined.Min = Min(&a.Min, &b.Min)
joined.Max = Max(&a.Max, &b.Max)
return joined
} | go | {
"resource": ""
} |
q11226 | Flatten | train | func Flatten(nested map[string]interface{}, prefix string, style SeparatorStyle) (map[string]interface{}, error) {
flatmap := make(map[string]interface{})
err := flatten(true, flatmap, nested, prefix, style)
if err != nil {
return nil, err
}
return flatmap, nil
} | go | {
"resource": ""
} |
q11227 | Setup | train | func Setup(c *caddy.Controller) error {
rules, err := parse(c)
if err != nil {
return err
}
c.OnStartup(func() error {
fmt.Println("JWT middleware is initiated")
return nil
})
host := httpserver.GetConfig(c).Addr.Host
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler... | go | {
"resource": ""
} |
q11228 | ExtractToken | train | func ExtractToken(tss []TokenSource, r *http.Request) (string, error) {
effectiveTss := tss
if len(effectiveTss) == 0 {
// Defaults are applied here as this keeps the tests the cleanest.
effectiveTss = DefaultTokenSources
}
for _, tss := range effectiveTss {
token := tss.ExtractToken(r)
if token != "" {
... | go | {
"resource": ""
} |
q11229 | handleUnauthorized | train | func handleUnauthorized(w http.ResponseWriter, r *http.Request, rule Rule, realm string) int {
if rule.Redirect != "" {
replacer := httpserver.NewReplacer(r, nil, "")
http.Redirect(w, r, replacer.Replace(rule.Redirect), http.StatusSeeOther)
return http.StatusSeeOther
}
w.Header().Add("WWW-Authenticate", fmt.S... | go | {
"resource": ""
} |
q11230 | contains | train | func contains(list interface{}, value string) bool {
switch l := list.(type) {
case []interface{}:
for _, v := range l {
if v == value {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q11231 | NewLazyPublicKeyFileBackend | train | func NewLazyPublicKeyFileBackend(value string) (*LazyPublicKeyBackend, error) {
if len(value) <= 0 {
return nil, fmt.Errorf("empty filename for public key provided")
}
return &LazyPublicKeyBackend{
filename: value,
}, nil
} | go | {
"resource": ""
} |
q11232 | NewLazyHmacKeyBackend | train | func NewLazyHmacKeyBackend(value string) (*LazyHmacKeyBackend, error) {
if len(value) <= 0 {
return nil, fmt.Errorf("empty filename for secret provided")
}
return &LazyHmacKeyBackend{
filename: value,
}, nil
} | go | {
"resource": ""
} |
q11233 | NewDefaultKeyBackends | train | func NewDefaultKeyBackends() ([]KeyBackend, error) {
result := []KeyBackend{}
secret := os.Getenv(ENV_SECRET)
if len(secret) > 0 {
result = append(result, &HmacKeyBackend{
secret: []byte(secret),
})
}
envPubKey := os.Getenv(ENV_PUBLIC_KEY)
if len(envPubKey) > 0 {
pub, err := ParsePublicKey([]byte(envPu... | go | {
"resource": ""
} |
q11234 | ProvideKey | train | func (instance *PublicKeyBackend) ProvideKey(token *jwt.Token) (interface{}, error) {
if err := AssertPublicKeyAndTokenCombination(instance.publicKey, token); err != nil {
return nil, err
}
return instance.publicKey, nil
} | go | {
"resource": ""
} |
q11235 | ProvideKey | train | func (instance *HmacKeyBackend) ProvideKey(token *jwt.Token) (interface{}, error) {
if err := AssertHmacToken(token); err != nil {
return nil, err
}
return instance.secret, nil
} | go | {
"resource": ""
} |
q11236 | ProvideKey | train | func (instance *NoopKeyBackend) ProvideKey(token *jwt.Token) (interface{}, error) {
return nil, fmt.Errorf("there is no keybackend available")
} | go | {
"resource": ""
} |
q11237 | DataPoint | train | func DataPoint(obs float64, vars []float64) *dataPoint {
return &dataPoint{Observed: obs, Variables: vars}
} | go | {
"resource": ""
} |
q11238 | Predict | train | func (r *Regression) Predict(vars []float64) (float64, error) {
if !r.initialised {
return 0, errNotEnoughData
}
// apply any features crosses to vars
for _, cross := range r.crosses {
vars = append(vars, cross.Calculate(vars)...)
}
p := r.Coeff(0)
for j := 1; j < len(r.data[0].Variables)+1; j++ {
p += r... | go | {
"resource": ""
} |
q11239 | SetVar | train | func (r *Regression) SetVar(i int, name string) {
if len(r.names.vars) == 0 {
r.names.vars = make(map[int]string, 5)
}
r.names.vars[i] = name
} | go | {
"resource": ""
} |
q11240 | GetVar | train | func (r *Regression) GetVar(i int) string {
x := r.names.vars[i]
if x == "" {
s := []string{"X", strconv.Itoa(i)}
return strings.Join(s, "")
}
return x
} | go | {
"resource": ""
} |
q11241 | AddCross | train | func (r *Regression) AddCross(cross featureCross) {
r.crosses = append(r.crosses, cross)
} | go | {
"resource": ""
} |
q11242 | Train | train | func (r *Regression) Train(d ...*dataPoint) {
r.data = append(r.data, d...)
if len(r.data) > 2 {
r.initialised = true
}
} | go | {
"resource": ""
} |
q11243 | Run | train | func (r *Regression) Run() error {
if !r.initialised {
return errNotEnoughData
}
if r.hasRun {
return errRegressionRun
}
//apply any features crosses
r.applyCrosses()
r.hasRun = true
observations := len(r.data)
numOfvars := len(r.data[0].Variables)
if observations < (numOfvars + 1) {
return errTooMan... | go | {
"resource": ""
} |
q11244 | Coeff | train | func (r *Regression) Coeff(i int) float64 {
if len(r.coeff) == 0 {
return 0
}
return r.coeff[i]
} | go | {
"resource": ""
} |
q11245 | String | train | func (d *dataPoint) String() string {
str := fmt.Sprintf("%.2f", d.Observed)
for _, v := range d.Variables {
str += fmt.Sprintf("|\t%.2f", v)
}
return str
} | go | {
"resource": ""
} |
q11246 | String | train | func (r *Regression) String() string {
if !r.initialised {
return errNotEnoughData.Error()
}
str := fmt.Sprintf("%v", r.GetObserved())
for i := 0; i < len(r.names.vars); i++ {
str += fmt.Sprintf("|\t%v", r.GetVar(i))
}
str += "\n"
for _, d := range r.data {
str += fmt.Sprintf("%v\n", d)
}
fmt.Println(r.c... | go | {
"resource": ""
} |
q11247 | PowCross | train | func PowCross(i int, power float64) featureCross {
return &functionalCross{
functionName: "^" + strconv.FormatFloat(power, 'f', -1, 64),
boundVars: []int{i},
crossFn: func(vars []float64) []float64 {
return []float64{math.Pow(vars[i], power)}
},
}
} | go | {
"resource": ""
} |
q11248 | MultiplierCross | train | func MultiplierCross(vars ...int) featureCross {
name := ""
for i, v := range vars {
name += strconv.Itoa(v)
if i < (len(vars) - 1) {
name += "*"
}
}
return &functionalCross{
functionName: name,
boundVars: vars,
crossFn: func(input []float64) []float64 {
var output float64 = 1
for _, variab... | go | {
"resource": ""
} |
q11249 | MicroService | train | func MicroService(s micro.Service) Option {
return func(o *Options) {
o.Service = s
}
} | go | {
"resource": ""
} |
q11250 | Flags | train | func Flags(flags ...cli.Flag) Option {
return func(o *Options) {
o.Flags = append(o.Flags, flags...)
}
} | go | {
"resource": ""
} |
q11251 | Action | train | func Action(a func(*cli.Context)) Option {
return func(o *Options) {
o.Action = a
}
} | go | {
"resource": ""
} |
q11252 | warmUpRequest | train | func warmUpRequest(appName string) {
Expect(helpers.CurlAppRoot(Config, appName)).To(ContainSubstring("hello i am nora running on"))
} | go | {
"resource": ""
} |
q11253 | UsageEventsAfterGuid | train | func UsageEventsAfterGuid(guid string) []AppUsageEvent {
resources := make([]AppUsageEvent, 0)
workflowhelpers.AsUser(TestSetup.AdminUserContext(), Config.DefaultTimeoutDuration(), func() {
firstPageUrl := "/v2/app_usage_events?results-per-page=150&order-direction=desc&page=1&after_guid=" + guid
url := firstPage... | go | {
"resource": ""
} |
q11254 | Purge | train | func (da *DigestAuth) Purge(count int) {
da.mutex.Lock()
defer da.mutex.Unlock()
entries := make([]digestCacheEntry, 0, len(da.clients))
for nonce, client := range da.clients {
entries = append(entries, digestCacheEntry{nonce, client.lastSeen})
}
cache := digestCache(entries)
sort.Sort(cache)
for _, client :=... | go | {
"resource": ""
} |
q11255 | DigestAuthParams | train | func DigestAuthParams(authorization string) map[string]string {
s := strings.SplitN(authorization, " ", 2)
if len(s) != 2 || s[0] != "Digest" {
return nil
}
return ParsePairs(s[1])
} | go | {
"resource": ""
} |
q11256 | JustCheck | train | func (da *DigestAuth) JustCheck(wrapped http.HandlerFunc) http.HandlerFunc {
return da.Wrap(func(w http.ResponseWriter, ar *AuthenticatedRequest) {
ar.Header.Set(AuthUsernameHeader, ar.Username)
wrapped(w, &ar.Request)
})
} | go | {
"resource": ""
} |
q11257 | NewDigestAuthenticator | train | func NewDigestAuthenticator(realm string, secrets SecretProvider) *DigestAuth {
da := &DigestAuth{
Opaque: RandomKey(),
Realm: realm,
Secrets: secrets,
PlainTextSecrets: false,
ClientCacheSize: DefaultClientCacheSize,
ClientCacheTolerance: DefaultClientCac... | go | {
"resource": ""
} |
q11258 | UpdateHeaders | train | func (i *Info) UpdateHeaders(headers http.Header) {
if i == nil {
return
}
for k, values := range i.ResponseHeaders {
for _, v := range values {
headers.Add(k, v)
}
}
} | go | {
"resource": ""
} |
q11259 | FromContext | train | func FromContext(ctx context.Context) *Info {
info, ok := ctx.Value(infoKey).(*Info)
if !ok {
return nil
}
return info
} | go | {
"resource": ""
} |
q11260 | JustCheck | train | func JustCheck(auth AuthenticatorInterface, wrapped http.HandlerFunc) http.HandlerFunc {
return auth.Wrap(func(w http.ResponseWriter, ar *AuthenticatedRequest) {
ar.Header.Set(AuthUsernameHeader, ar.Username)
wrapped(w, &ar.Request)
})
} | go | {
"resource": ""
} |
q11261 | RandomKey | train | func RandomKey() string {
k := make([]byte, 12)
for bytes := 0; bytes < len(k); {
n, err := rand.Read(k[bytes:])
if err != nil {
panic("rand.Read() failed")
}
bytes += n
}
return base64.StdEncoding.EncodeToString(k)
} | go | {
"resource": ""
} |
q11262 | CheckSecret | train | func CheckSecret(password, secret string) bool {
compare := compareFuncs[0].compare
for _, cmp := range compareFuncs[1:] {
if strings.HasPrefix(secret, cmp.prefix) {
compare = cmp.compare
break
}
}
return compare([]byte(secret), []byte(password)) == nil
} | go | {
"resource": ""
} |
q11263 | HtdigestFileProvider | train | func HtdigestFileProvider(filename string) SecretProvider {
hf := &HtdigestFile{File: File{Path: filename}}
hf.Reload = func() { reloadHTDigest(hf) }
return func(user, realm string) string {
hf.ReloadIfNeeded()
hf.mu.RLock()
defer hf.mu.RUnlock()
_, exists := hf.Users[realm]
if !exists {
return ""
}
... | go | {
"resource": ""
} |
q11264 | HtpasswdFileProvider | train | func HtpasswdFileProvider(filename string) SecretProvider {
h := &HtpasswdFile{File: File{Path: filename}}
h.Reload = func() { reloadHTPasswd(h) }
return func(user, realm string) string {
h.ReloadIfNeeded()
h.mu.RLock()
password, exists := h.Users[user]
h.mu.RUnlock()
if !exists {
return ""
}
return... | go | {
"resource": ""
} |
q11265 | MD5Crypt | train | func MD5Crypt(password, salt, magic []byte) []byte {
d := md5.New()
d.Write(password)
d.Write(magic)
d.Write(salt)
d2 := md5.New()
d2.Write(password)
d2.Write(salt)
d2.Write(password)
for i, mixin := 0, d2.Sum(nil); i < len(password); i++ {
d.Write([]byte{mixin[i%16]})
}
for i := len(password); i != 0;... | go | {
"resource": ""
} |
q11266 | NewFamily | train | func NewFamily(dtoMF *dto.MetricFamily) *Family {
mf := &Family{
//Time: time.Now(),
Name: dtoMF.GetName(),
Help: dtoMF.GetHelp(),
Type: dtoMF.GetType().String(),
Metrics: make([]interface{}, len(dtoMF.Metric)),
}
for i, m := range dtoMF.Metric {
if dtoMF.GetType() == dto.MetricType_SUMMARY {... | go | {
"resource": ""
} |
q11267 | FetchMetricFamilies | train | func FetchMetricFamilies(
url string, ch chan<- *dto.MetricFamily,
certificate string, key string,
skipServerCertCheck bool,
) error {
var transport *http.Transport
if certificate != "" && key != "" {
cert, err := tls.LoadX509KeyPair(certificate, key)
if err != nil {
return err
}
tlsConfig := &tls.Confi... | go | {
"resource": ""
} |
q11268 | ParseResponse | train | func ParseResponse(resp *http.Response, ch chan<- *dto.MetricFamily) error {
mediatype, params, err := mime.ParseMediaType(resp.Header.Get("Content-Type"))
if err == nil && mediatype == "application/vnd.google.protobuf" &&
params["encoding"] == "delimited" &&
params["proto"] == "io.prometheus.client.MetricFamily"... | go | {
"resource": ""
} |
q11269 | ParseReader | train | func ParseReader(in io.Reader, ch chan<- *dto.MetricFamily) error {
defer close(ch)
// We could do further content-type checks here, but the
// fallback for now will anyway be the text format
// version 0.0.4, so just go for it and see if it works.
var parser expfmt.TextParser
metricFamilies, err := parser.TextTo... | go | {
"resource": ""
} |
q11270 | fixRoutingRules | train | func (d *Driver) fixRoutingRules(sshClient ssh.Client) {
output, err := sshClient.Output("route del -net 172.16.0.0/12")
log.Debugf("%s | Delete route command err, output: %v: %s", d.MachineName, err, output)
output, err = sshClient.Output("if [ -e /etc/network/interfaces ]; then sed -i '/^up route add -net 172.16.... | go | {
"resource": ""
} |
q11271 | autoFdisk | train | func (d *Driver) autoFdisk(sshClient ssh.Client) {
s := autoFdiskScriptExt4
if d.DiskFS == "xfs" {
s = autoFdiskScriptXFS
}
script := fmt.Sprintf("cat > ~/machine_autofdisk.sh <<MACHINE_EOF\n%s\nMACHINE_EOF\n", s)
output, err := sshClient.Output(script)
output, err = sshClient.Output("bash ~/machine_autofdis... | go | {
"resource": ""
} |
q11272 | NewSpdyStreamProvider | train | func NewSpdyStreamProvider(conn net.Conn, server bool) (StreamProvider, error) {
spdyConn, spdyErr := spdystream.NewConnection(conn, server)
if spdyErr != nil {
return nil, spdyErr
}
provider := &spdyStreamProvider{
conn: spdyConn,
closeChan: make(chan struct{}),
listenChan: make(chan *spdyStream),
... | go | {
"resource": ""
} |
q11273 | NewTransport | train | func NewTransport(provider StreamProvider) libchan.Transport {
session := &Transport{
provider: provider,
referenceCounter: 1,
receiverChan: make(chan *receiver),
streamC: sync.NewCond(new(sync.Mutex)),
streams: make(map[uint64]*stream),
}
go session.handleStreams()
return ... | go | {
"resource": ""
} |
q11274 | NewSendChannel | train | func (s *Transport) NewSendChannel() (libchan.Sender, error) {
stream, err := s.createSubStream(0)
if err != nil {
return nil, err
}
// TODO check synchronized
return &sender{stream: stream}, nil
} | go | {
"resource": ""
} |
q11275 | WaitReceiveChannel | train | func (s *Transport) WaitReceiveChannel() (libchan.Receiver, error) {
r, ok := <-s.receiverChan
if !ok {
return nil, io.EOF
}
return r, nil
} | go | {
"resource": ""
} |
q11276 | CreateNestedReceiver | train | func (s *stream) CreateNestedReceiver() (libchan.Receiver, libchan.Sender, error) {
stream, err := s.session.createSubStream(s.referenceID)
if err != nil {
return nil, nil, err
}
return &receiver{stream: stream}, &nopSender{stream: stream}, err
} | go | {
"resource": ""
} |
q11277 | CreateNestedSender | train | func (s *stream) CreateNestedSender() (libchan.Sender, libchan.Receiver, error) {
stream, err := s.session.createSubStream(s.referenceID)
if err != nil {
return nil, nil, err
}
return &sender{stream: stream}, &nopReceiver{stream: stream}, err
} | go | {
"resource": ""
} |
q11278 | Send | train | func (s *sender) Send(message interface{}) error {
s.encodeLock.Lock()
defer s.encodeLock.Unlock()
if s.encoder == nil {
s.buffer = bufio.NewWriter(s.stream)
s.encoder = msgpack.NewEncoder(s.buffer)
s.encoder.AddExtensions(s.stream.initializeExtensions())
}
if err := s.encoder.Encode(message); err != nil {
... | go | {
"resource": ""
} |
q11279 | Receive | train | func (r *receiver) Receive(message interface{}) error {
r.decodeLock.Lock()
defer r.decodeLock.Unlock()
if r.decoder == nil {
r.decoder = msgpack.NewDecoder(r.stream)
r.decoder.AddExtensions(r.stream.initializeExtensions())
}
decodeErr := r.decoder.Decode(message)
if decodeErr == io.EOF {
r.stream.Close()
... | go | {
"resource": ""
} |
q11280 | BufferedPipe | train | func BufferedPipe(n int) (Receiver, Sender) {
c := make(chan interface{}, n)
return pReceiver(c), pSender(c)
} | go | {
"resource": ""
} |
q11281 | Pipe | train | func Pipe() (libchan.Receiver, libchan.Sender, error) {
c1, c2 := net.Pipe()
s1, err := NewSpdyStreamProvider(c1, false)
if err != nil {
return nil, nil, err
}
t1 := NewTransport(s1)
s2, err := NewSpdyStreamProvider(c2, true)
if err != nil {
return nil, nil, err
}
t2 := NewTransport(s2)
var recv libcha... | go | {
"resource": ""
} |
q11282 | Copy | train | func Copy(w Sender, r Receiver) (int, error) {
if senderTo, ok := r.(SenderTo); ok {
if n, err := senderTo.SendTo(w); err != ErrIncompatibleSender {
return n, err
}
}
if receiverFrom, ok := w.(ReceiverFrom); ok {
if n, err := receiverFrom.ReceiveFrom(r); err != ErrIncompatibleReceiver {
return n, err
}... | go | {
"resource": ""
} |
q11283 | execute | train | func execute(s string, vars map[string]interface{}) (string, error) {
expr, diags := hclsyntax.ParseTemplate([]byte(s), "<template_file>", hcl.Pos{Line: 1, Column: 1})
if diags.HasErrors() {
return "", diags
}
ctx := &hcl.EvalContext{
Variables: map[string]cty.Value{},
}
for k, v := range vars {
// In prac... | go | {
"resource": ""
} |
q11284 | FlattenString | train | func FlattenString(nestedstr, prefix string, style SeparatorStyle) (string, error) {
var nested map[string]interface{}
err := json.Unmarshal([]byte(nestedstr), &nested)
if err != nil {
return "", err
}
flatmap, err := Flatten(nested, prefix, style)
if err != nil {
return "", err
}
flatb, err := json.Marsh... | go | {
"resource": ""
} |
q11285 | GetSpec | train | func GetSpec() *plugin.MiddlewareSpec {
cliFlags := []cli.Flag{
cli.IntFlag{Name: "period", Value: 1, Usage: "rate limit period in seconds"},
cli.IntFlag{Name: "requests", Value: 1, Usage: "amount of requests"},
cli.IntFlag{Name: "burst", Value: 1, Usage: "allowed burst"},
cli.StringFlag{Name: "variable, var",... | go | {
"resource": ""
} |
q11286 | FromCli | train | func FromCli(c *cli.Context) (plugin.Middleware, error) {
return FromOther(
RateLimit{
PeriodSeconds: int64(c.Int("period")),
Requests: int64(c.Int("requests")),
Burst: int64(c.Int("burst")),
Variable: c.String("var"),
RateVar: c.String("rateVar")})
} | go | {
"resource": ""
} |
q11287 | getHeapProfile | train | func getHeapProfile(w http.ResponseWriter, r *http.Request) {
// Ensure up-to-date data.
runtime.GC()
w.Header().Set("Content-Type", "application/octet-stream")
if err := pprof.Lookup("heap").WriteTo(w, 0); err != nil {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusInterna... | go | {
"resource": ""
} |
q11288 | parseForm | train | func parseForm(r *http.Request) error {
contentType := r.Header.Get("Content-Type")
if strings.HasPrefix(contentType, "multipart/form-data") == true {
return r.ParseMultipartForm(0)
}
return r.ParseForm()
} | go | {
"resource": ""
} |
q11289 | FromCli | train | func FromCli(c *cli.Context) (plugin.Middleware, error) {
return NewConnLimit(int64(c.Int("connections")), c.String("var"))
} | go | {
"resource": ""
} |
q11290 | run | train | func (s *Supervisor) run() {
defer s.stopWg.Done()
for {
select {
case <-s.watcherErrorC:
s.watcherWg.Wait()
s.watcherErrorC = nil
case <-s.stopC:
close(s.watcherCancelC)
s.engine.Close()
s.watcherWg.Wait()
if s.proxy != nil {
s.proxy.Stop(true)
}
return
}
err := s.init()
// I... | go | {
"resource": ""
} |
q11291 | processChange | train | func processChange(p proxy.Proxy, ch interface{}) error {
switch change := ch.(type) {
case *engine.HostUpserted:
return p.UpsertHost(change.Host)
case *engine.HostDeleted:
return p.DeleteHost(change.HostKey)
case *engine.ListenerUpserted:
return p.UpsertListener(change.Listener)
case *engine.ListenerDelet... | go | {
"resource": ""
} |
q11292 | MarkServerAnomalies | train | func MarkServerAnomalies(servers []engine.Server) error {
if len(servers) == 0 {
return nil
}
stats := make([]engine.RoundTripStats, len(servers))
for i := range servers {
stats[i] = *servers[i].Stats
}
if err := MarkAnomalies(stats); err != nil {
return err
}
for i := range stats {
servers[i].Stats =... | go | {
"resource": ""
} |
q11293 | MarkAnomalies | train | func MarkAnomalies(stats []engine.RoundTripStats) error {
if len(stats) == 0 {
return nil
}
if err := markLatencies(stats); err != nil {
return err
}
if err := markNetErrorRates(stats); err != nil {
return err
}
return markAppErrorRates(stats)
} | go | {
"resource": ""
} |
q11294 | New | train | func New(cfg engine.Frontend, be *backend.T, opts proxy.Options,
mwCfgs map[engine.MiddlewareKey]engine.Middleware,
listeners plugin.FrontendListeners,
) *T {
if mwCfgs == nil {
mwCfgs = make(map[engine.MiddlewareKey]engine.Middleware)
}
fe := T{
cfg: cfg,
trustXFDH: opts.TrustForwardHeader,
mwCfgs: ... | go | {
"resource": ""
} |
q11295 | BackendKey | train | func (fe *T) BackendKey() engine.BackendKey {
fe.mu.Lock()
beKey := fe.backend.Key()
fe.mu.Unlock()
return beKey
} | go | {
"resource": ""
} |
q11296 | Route | train | func (fe *T) Route() string {
fe.mu.Lock()
route := fe.cfg.Route
fe.mu.Unlock()
return route
} | go | {
"resource": ""
} |
q11297 | UpsertMiddleware | train | func (fe *T) UpsertMiddleware(mwCfg engine.Middleware) {
fe.mu.Lock()
defer fe.mu.Unlock()
mwKey := engine.MiddlewareKey{FrontendKey: engine.FrontendKey{Id: fe.cfg.Id}, Id: mwCfg.Id}
fe.mwCfgs[mwKey] = mwCfg
fe.ready = false
} | go | {
"resource": ""
} |
q11298 | DeleteMiddleware | train | func (fe *T) DeleteMiddleware(mwKey engine.MiddlewareKey) {
fe.mu.Lock()
defer fe.mu.Unlock()
if _, ok := fe.mwCfgs[mwKey]; !ok {
return
}
delete(fe.mwCfgs, mwKey)
fe.ready = false
} | go | {
"resource": ""
} |
q11299 | CfgWithStats | train | func (fe *T) CfgWithStats() (engine.Frontend, bool, error) {
fe.mu.Lock()
rtmCollect := fe.rtmCollect
feCfg := fe.cfg
fe.mu.Unlock()
if rtmCollect == nil {
return engine.Frontend{}, false, nil
}
var err error
if feCfg.Stats, err = rtmCollect.RTStats(); err != nil {
return engine.Frontend{}, false, errors.W... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.