id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
13,600 | qlik-oss/enigma-go | pending_call_registry.go | WithReservedRequestID | func (q *pendingCallRegistry) WithReservedRequestID(ctx context.Context) (context.Context, int) {
q.mutex.Lock()
defer q.mutex.Unlock()
q.callIDSeq++
id := q.callIDSeq
newContext := context.WithValue(ctx, reservedRequestIDKey{}, id)
return newContext, id
} | go | func (q *pendingCallRegistry) WithReservedRequestID(ctx context.Context) (context.Context, int) {
q.mutex.Lock()
defer q.mutex.Unlock()
q.callIDSeq++
id := q.callIDSeq
newContext := context.WithValue(ctx, reservedRequestIDKey{}, id)
return newContext, id
} | [
"func",
"(",
"q",
"*",
"pendingCallRegistry",
")",
"WithReservedRequestID",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"context",
".",
"Context",
",",
"int",
")",
"{",
"q",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"defer",
"q",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"q",
".",
"callIDSeq",
"++",
"\n",
"id",
":=",
"q",
".",
"callIDSeq",
"\n",
"newContext",
":=",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"reservedRequestIDKey",
"{",
"}",
",",
"id",
")",
"\n",
"return",
"newContext",
",",
"id",
"\n",
"}"
] | // Creates a new context that contains a reserved JSON RPC protocol level request id.
// It can be for instance be useful when the request id used for upcoming call needs to be known. | [
"Creates",
"a",
"new",
"context",
"that",
"contains",
"a",
"reserved",
"JSON",
"RPC",
"protocol",
"level",
"request",
"id",
".",
"It",
"can",
"be",
"for",
"instance",
"be",
"useful",
"when",
"the",
"request",
"id",
"used",
"for",
"upcoming",
"call",
"needs",
"to",
"be",
"known",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/pending_call_registry.go#L65-L72 |
13,601 | qlik-oss/enigma-go | remote_object.go | ChangedChannel | func (r *RemoteObject) ChangedChannel() chan struct{} {
channel := make(chan struct{}, 16)
r.changedChannels[channel] = true
return channel
} | go | func (r *RemoteObject) ChangedChannel() chan struct{} {
channel := make(chan struct{}, 16)
r.changedChannels[channel] = true
return channel
} | [
"func",
"(",
"r",
"*",
"RemoteObject",
")",
"ChangedChannel",
"(",
")",
"chan",
"struct",
"{",
"}",
"{",
"channel",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
",",
"16",
")",
"\n",
"r",
".",
"changedChannels",
"[",
"channel",
"]",
"=",
"true",
"\n",
"return",
"channel",
"\n",
"}"
] | // ChangedChannel returns a channel that will receive changes when the underlying object is invalidated. | [
"ChangedChannel",
"returns",
"a",
"channel",
"that",
"will",
"receive",
"changes",
"when",
"the",
"underlying",
"object",
"is",
"invalidated",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/remote_object.go#L21-L25 |
13,602 | qlik-oss/enigma-go | remote_object.go | RemoveChangeChannel | func (r *RemoteObject) RemoveChangeChannel(channel chan struct{}) {
r.mutex.Lock()
if r.changedChannels[channel] != false {
delete(r.changedChannels, channel)
close(channel)
}
r.mutex.Unlock()
} | go | func (r *RemoteObject) RemoveChangeChannel(channel chan struct{}) {
r.mutex.Lock()
if r.changedChannels[channel] != false {
delete(r.changedChannels, channel)
close(channel)
}
r.mutex.Unlock()
} | [
"func",
"(",
"r",
"*",
"RemoteObject",
")",
"RemoveChangeChannel",
"(",
"channel",
"chan",
"struct",
"{",
"}",
")",
"{",
"r",
".",
"mutex",
".",
"Lock",
"(",
")",
"\n",
"if",
"r",
".",
"changedChannels",
"[",
"channel",
"]",
"!=",
"false",
"{",
"delete",
"(",
"r",
".",
"changedChannels",
",",
"channel",
")",
"\n",
"close",
"(",
"channel",
")",
"\n",
"}",
"\n",
"r",
".",
"mutex",
".",
"Unlock",
"(",
")",
"\n",
"}"
] | // RemoveChangeChannel unregisters a channel from further events. | [
"RemoveChangeChannel",
"unregisters",
"a",
"channel",
"from",
"further",
"events",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/remote_object.go#L28-L35 |
13,603 | qlik-oss/enigma-go | remote_object.go | rpc | func (r *RemoteObject) rpc(ctx context.Context, method string, apiResponse interface{}, params ...interface{}) error {
invocationResponse := r.interceptorChain(ctx, &Invocation{RemoteObject: r, Method: method, Params: params})
if invocationResponse.Error != nil {
return invocationResponse.Error
}
if apiResponse != nil {
err := json.Unmarshal(invocationResponse.Result, apiResponse)
if err != nil {
return err
}
}
return nil
} | go | func (r *RemoteObject) rpc(ctx context.Context, method string, apiResponse interface{}, params ...interface{}) error {
invocationResponse := r.interceptorChain(ctx, &Invocation{RemoteObject: r, Method: method, Params: params})
if invocationResponse.Error != nil {
return invocationResponse.Error
}
if apiResponse != nil {
err := json.Unmarshal(invocationResponse.Result, apiResponse)
if err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"r",
"*",
"RemoteObject",
")",
"rpc",
"(",
"ctx",
"context",
".",
"Context",
",",
"method",
"string",
",",
"apiResponse",
"interface",
"{",
"}",
",",
"params",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"invocationResponse",
":=",
"r",
".",
"interceptorChain",
"(",
"ctx",
",",
"&",
"Invocation",
"{",
"RemoteObject",
":",
"r",
",",
"Method",
":",
"method",
",",
"Params",
":",
"params",
"}",
")",
"\n",
"if",
"invocationResponse",
".",
"Error",
"!=",
"nil",
"{",
"return",
"invocationResponse",
".",
"Error",
"\n",
"}",
"\n",
"if",
"apiResponse",
"!=",
"nil",
"{",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"invocationResponse",
".",
"Result",
",",
"apiResponse",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Invokes a method on the remote object | [
"Invokes",
"a",
"method",
"on",
"the",
"remote",
"object"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/remote_object.go#L65-L77 |
13,604 | qlik-oss/enigma-go | remote_object.go | newRemoteObject | func newRemoteObject(session *session, objectInterface *ObjectInterface) *RemoteObject {
remoteObject := &RemoteObject{
session: session,
ObjectInterface: objectInterface,
changedChannels: make(map[chan struct{}]bool),
mutex: sync.Mutex{},
closedCh: make(chan struct{}),
}
// Signal that the object is by definition changed from the beginning
return remoteObject
} | go | func newRemoteObject(session *session, objectInterface *ObjectInterface) *RemoteObject {
remoteObject := &RemoteObject{
session: session,
ObjectInterface: objectInterface,
changedChannels: make(map[chan struct{}]bool),
mutex: sync.Mutex{},
closedCh: make(chan struct{}),
}
// Signal that the object is by definition changed from the beginning
return remoteObject
} | [
"func",
"newRemoteObject",
"(",
"session",
"*",
"session",
",",
"objectInterface",
"*",
"ObjectInterface",
")",
"*",
"RemoteObject",
"{",
"remoteObject",
":=",
"&",
"RemoteObject",
"{",
"session",
":",
"session",
",",
"ObjectInterface",
":",
"objectInterface",
",",
"changedChannels",
":",
"make",
"(",
"map",
"[",
"chan",
"struct",
"{",
"}",
"]",
"bool",
")",
",",
"mutex",
":",
"sync",
".",
"Mutex",
"{",
"}",
",",
"closedCh",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
",",
"}",
"\n",
"// Signal that the object is by definition changed from the beginning",
"return",
"remoteObject",
"\n",
"}"
] | // newRemoteObject creates a new RemoteObject instance | [
"newRemoteObject",
"creates",
"a",
"new",
"RemoteObject",
"instance"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/remote_object.go#L80-L90 |
13,605 | qlik-oss/enigma-go | schema/generate.go | UnmarshalText | func (k *OrderAwareKey) UnmarshalText(text []byte) error {
i := atomic.AddUint64(&keyOrderCounter, 1)
k.Order = i
k.Key = string(text)
return nil
} | go | func (k *OrderAwareKey) UnmarshalText(text []byte) error {
i := atomic.AddUint64(&keyOrderCounter, 1)
k.Order = i
k.Key = string(text)
return nil
} | [
"func",
"(",
"k",
"*",
"OrderAwareKey",
")",
"UnmarshalText",
"(",
"text",
"[",
"]",
"byte",
")",
"error",
"{",
"i",
":=",
"atomic",
".",
"AddUint64",
"(",
"&",
"keyOrderCounter",
",",
"1",
")",
"\n",
"k",
".",
"Order",
"=",
"i",
"\n",
"k",
".",
"Key",
"=",
"string",
"(",
"text",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalText allows OrderAwareKey to be used as a json map key | [
"UnmarshalText",
"allows",
"OrderAwareKey",
"to",
"be",
"used",
"as",
"a",
"json",
"map",
"key"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/schema/generate.go#L111-L116 |
13,606 | qlik-oss/enigma-go | schema/generate.go | printMethod | func printMethod(method *Methodx, out *os.File, serviceName string, methodName string, objectFuncToObject map[string]string) {
actualResponses := filterResponses(method.Responses, methodName)
// Generate Description
if method.Description != "" {
fmt.Fprintln(out, formatComment("", method.Description, method.Parameters))
}
fmt.Fprint(out, "func (obj *", serviceName, ") ", methodName, "(ctx context.Context")
// Generate Parameters
for _, param := range method.Parameters {
fmt.Fprint(out, ", ", "", toParamName(param.Name), " ", getTypeName(param))
}
fmt.Fprint(out, ") ")
// Generate Return Types
if len(actualResponses) > 0 {
fmt.Fprint(out, "(")
}
for _, response := range actualResponses {
typeName := getTypeName(response)
if typeName == "*ObjectInterface" {
// Replace the generic ObjectInterface pointer with the right Remote Object API struct
objectTypeName := objectFuncToObject[serviceName+"."+methodName]
if objectTypeName == "" {
panic("Unknown remote object type for " + serviceName + "." + methodName)
}
fmt.Fprint(out, "*"+objectTypeName, ", ")
} else {
fmt.Fprint(out, getTypeName(response), ", ")
}
}
fmt.Fprint(out, "error")
if len(actualResponses) > 0 {
fmt.Fprint(out, ")")
}
// Generate Start of Function body
fmt.Fprintln(out, " {")
// Generate an anonymous result container struct
var resultParamName string
if len(method.Responses) > 0 {
fmt.Fprintln(out, "\tresult := &struct {")
for _, response := range method.Responses {
fmt.Fprintln(out, "\t\t"+toPublicMemberName(response.Name), getTypeName(response)+"\t`json:\""+response.Name+"\"`")
}
fmt.Fprintln(out, "\t} {}")
resultParamName = "result"
} else {
resultParamName = "nil"
}
// Generate the actual call down to the RPC machinery
fmt.Fprint(out, "\terr := obj.rpc(ctx, \"", methodName, "\", ", resultParamName)
for _, param := range method.Parameters {
// Fill in the parameters in the parameter array
fmt.Fprint(out, ", ", toParamName(param.Name))
}
fmt.Fprintln(out, ")")
// If there is at least one Remote Object that will be created then check for nil and return early
if atLeastOneObjectInterface(method) {
fmt.Fprintln(out, "\tif err != nil {")
fmt.Fprint(out, "\t\treturn ")
for _, response := range actualResponses {
fmt.Fprint(out, nilNameInEarlyReturnAfterError(response.Type)+", ")
}
fmt.Fprintln(out, "err")
fmt.Fprintln(out, "\t}")
}
fmt.Fprint(out, getExtraCrossAssignmentLine(methodName))
// Return the result including creating a new Remote Object if needed
fmt.Fprint(out, "\treturn ")
for _, response := range actualResponses {
if getTypeName(response) == "*ObjectInterface" {
objectAPITypeName := objectFuncToObject[serviceName+"."+methodName]
fmt.Fprint(out, "&"+objectAPITypeName+"{obj.session.getRemoteObject(result."+response.Name[1:]+")}, ")
} else {
fmt.Fprint(out, "result."+toPublicMemberName(response.Name)+", ")
}
}
fmt.Fprintln(out, "err ")
fmt.Fprintln(out, "}")
fmt.Fprintln(out, "")
} | go | func printMethod(method *Methodx, out *os.File, serviceName string, methodName string, objectFuncToObject map[string]string) {
actualResponses := filterResponses(method.Responses, methodName)
// Generate Description
if method.Description != "" {
fmt.Fprintln(out, formatComment("", method.Description, method.Parameters))
}
fmt.Fprint(out, "func (obj *", serviceName, ") ", methodName, "(ctx context.Context")
// Generate Parameters
for _, param := range method.Parameters {
fmt.Fprint(out, ", ", "", toParamName(param.Name), " ", getTypeName(param))
}
fmt.Fprint(out, ") ")
// Generate Return Types
if len(actualResponses) > 0 {
fmt.Fprint(out, "(")
}
for _, response := range actualResponses {
typeName := getTypeName(response)
if typeName == "*ObjectInterface" {
// Replace the generic ObjectInterface pointer with the right Remote Object API struct
objectTypeName := objectFuncToObject[serviceName+"."+methodName]
if objectTypeName == "" {
panic("Unknown remote object type for " + serviceName + "." + methodName)
}
fmt.Fprint(out, "*"+objectTypeName, ", ")
} else {
fmt.Fprint(out, getTypeName(response), ", ")
}
}
fmt.Fprint(out, "error")
if len(actualResponses) > 0 {
fmt.Fprint(out, ")")
}
// Generate Start of Function body
fmt.Fprintln(out, " {")
// Generate an anonymous result container struct
var resultParamName string
if len(method.Responses) > 0 {
fmt.Fprintln(out, "\tresult := &struct {")
for _, response := range method.Responses {
fmt.Fprintln(out, "\t\t"+toPublicMemberName(response.Name), getTypeName(response)+"\t`json:\""+response.Name+"\"`")
}
fmt.Fprintln(out, "\t} {}")
resultParamName = "result"
} else {
resultParamName = "nil"
}
// Generate the actual call down to the RPC machinery
fmt.Fprint(out, "\terr := obj.rpc(ctx, \"", methodName, "\", ", resultParamName)
for _, param := range method.Parameters {
// Fill in the parameters in the parameter array
fmt.Fprint(out, ", ", toParamName(param.Name))
}
fmt.Fprintln(out, ")")
// If there is at least one Remote Object that will be created then check for nil and return early
if atLeastOneObjectInterface(method) {
fmt.Fprintln(out, "\tif err != nil {")
fmt.Fprint(out, "\t\treturn ")
for _, response := range actualResponses {
fmt.Fprint(out, nilNameInEarlyReturnAfterError(response.Type)+", ")
}
fmt.Fprintln(out, "err")
fmt.Fprintln(out, "\t}")
}
fmt.Fprint(out, getExtraCrossAssignmentLine(methodName))
// Return the result including creating a new Remote Object if needed
fmt.Fprint(out, "\treturn ")
for _, response := range actualResponses {
if getTypeName(response) == "*ObjectInterface" {
objectAPITypeName := objectFuncToObject[serviceName+"."+methodName]
fmt.Fprint(out, "&"+objectAPITypeName+"{obj.session.getRemoteObject(result."+response.Name[1:]+")}, ")
} else {
fmt.Fprint(out, "result."+toPublicMemberName(response.Name)+", ")
}
}
fmt.Fprintln(out, "err ")
fmt.Fprintln(out, "}")
fmt.Fprintln(out, "")
} | [
"func",
"printMethod",
"(",
"method",
"*",
"Methodx",
",",
"out",
"*",
"os",
".",
"File",
",",
"serviceName",
"string",
",",
"methodName",
"string",
",",
"objectFuncToObject",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"actualResponses",
":=",
"filterResponses",
"(",
"method",
".",
"Responses",
",",
"methodName",
")",
"\n",
"// Generate Description",
"if",
"method",
".",
"Description",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"formatComment",
"(",
"\"",
"\"",
",",
"method",
".",
"Description",
",",
"method",
".",
"Parameters",
")",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
",",
"serviceName",
",",
"\"",
"\"",
",",
"methodName",
",",
"\"",
"\"",
")",
"\n\n",
"// Generate Parameters",
"for",
"_",
",",
"param",
":=",
"range",
"method",
".",
"Parameters",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"toParamName",
"(",
"param",
".",
"Name",
")",
",",
"\"",
"\"",
",",
"getTypeName",
"(",
"param",
")",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
")",
"\n\n",
"// Generate Return Types",
"if",
"len",
"(",
"actualResponses",
")",
">",
"0",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"response",
":=",
"range",
"actualResponses",
"{",
"typeName",
":=",
"getTypeName",
"(",
"response",
")",
"\n",
"if",
"typeName",
"==",
"\"",
"\"",
"{",
"// Replace the generic ObjectInterface pointer with the right Remote Object API struct",
"objectTypeName",
":=",
"objectFuncToObject",
"[",
"serviceName",
"+",
"\"",
"\"",
"+",
"methodName",
"]",
"\n",
"if",
"objectTypeName",
"==",
"\"",
"\"",
"{",
"panic",
"(",
"\"",
"\"",
"+",
"serviceName",
"+",
"\"",
"\"",
"+",
"methodName",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
"+",
"objectTypeName",
",",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"getTypeName",
"(",
"response",
")",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"if",
"len",
"(",
"actualResponses",
")",
">",
"0",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Generate Start of Function body",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n\n",
"// Generate an anonymous result container struct",
"var",
"resultParamName",
"string",
"\n",
"if",
"len",
"(",
"method",
".",
"Responses",
")",
">",
"0",
"{",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"for",
"_",
",",
"response",
":=",
"range",
"method",
".",
"Responses",
"{",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\\t",
"\\t",
"\"",
"+",
"toPublicMemberName",
"(",
"response",
".",
"Name",
")",
",",
"getTypeName",
"(",
"response",
")",
"+",
"\"",
"\\t",
"\\\"",
"\"",
"+",
"response",
".",
"Name",
"+",
"\"",
"\\\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"resultParamName",
"=",
"\"",
"\"",
"\n",
"}",
"else",
"{",
"resultParamName",
"=",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// Generate the actual call down to the RPC machinery",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\\t",
"\\\"",
"\"",
",",
"methodName",
",",
"\"",
"\\\"",
"\"",
",",
"resultParamName",
")",
"\n",
"for",
"_",
",",
"param",
":=",
"range",
"method",
".",
"Parameters",
"{",
"// Fill in the parameters in the parameter array",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
",",
"toParamName",
"(",
"param",
".",
"Name",
")",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n\n",
"// If there is at least one Remote Object that will be created then check for nil and return early",
"if",
"atLeastOneObjectInterface",
"(",
"method",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\\t",
"\\t",
"\"",
")",
"\n",
"for",
"_",
",",
"response",
":=",
"range",
"actualResponses",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"nilNameInEarlyReturnAfterError",
"(",
"response",
".",
"Type",
")",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"getExtraCrossAssignmentLine",
"(",
"methodName",
")",
")",
"\n\n",
"// Return the result including creating a new Remote Object if needed",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\\t",
"\"",
")",
"\n",
"for",
"_",
",",
"response",
":=",
"range",
"actualResponses",
"{",
"if",
"getTypeName",
"(",
"response",
")",
"==",
"\"",
"\"",
"{",
"objectAPITypeName",
":=",
"objectFuncToObject",
"[",
"serviceName",
"+",
"\"",
"\"",
"+",
"methodName",
"]",
"\n",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
"+",
"objectAPITypeName",
"+",
"\"",
"\"",
"+",
"response",
".",
"Name",
"[",
"1",
":",
"]",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprint",
"(",
"out",
",",
"\"",
"\"",
"+",
"toPublicMemberName",
"(",
"response",
".",
"Name",
")",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"}"
] | // Generate an ordinary fully typed method | [
"Generate",
"an",
"ordinary",
"fully",
"typed",
"method"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/schema/generate.go#L445-L533 |
13,607 | qlik-oss/enigma-go | float.go | UnmarshalJSON | func (value *Float64) UnmarshalJSON(arg []byte) error {
err := json.Unmarshal(arg, (*float64)(value))
if err != nil {
str := string(arg)
switch str {
case `"NaN"`:
*value = Float64(math.NaN())
case `"Infinity"`:
*value = Float64(math.Inf(1))
case `"-Infinity"`:
*value = Float64(math.Inf(-1))
default:
return err
}
}
return nil
} | go | func (value *Float64) UnmarshalJSON(arg []byte) error {
err := json.Unmarshal(arg, (*float64)(value))
if err != nil {
str := string(arg)
switch str {
case `"NaN"`:
*value = Float64(math.NaN())
case `"Infinity"`:
*value = Float64(math.Inf(1))
case `"-Infinity"`:
*value = Float64(math.Inf(-1))
default:
return err
}
}
return nil
} | [
"func",
"(",
"value",
"*",
"Float64",
")",
"UnmarshalJSON",
"(",
"arg",
"[",
"]",
"byte",
")",
"error",
"{",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"arg",
",",
"(",
"*",
"float64",
")",
"(",
"value",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"str",
":=",
"string",
"(",
"arg",
")",
"\n",
"switch",
"str",
"{",
"case",
"`\"NaN\"`",
":",
"*",
"value",
"=",
"Float64",
"(",
"math",
".",
"NaN",
"(",
")",
")",
"\n",
"case",
"`\"Infinity\"`",
":",
"*",
"value",
"=",
"Float64",
"(",
"math",
".",
"Inf",
"(",
"1",
")",
")",
"\n",
"case",
"`\"-Infinity\"`",
":",
"*",
"value",
"=",
"Float64",
"(",
"math",
".",
"Inf",
"(",
"-",
"1",
")",
")",
"\n",
"default",
":",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // UnmarshalJSON implements the Unmarshaler interface for custom unmarshalling. | [
"UnmarshalJSON",
"implements",
"the",
"Unmarshaler",
"interface",
"for",
"custom",
"unmarshalling",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/float.go#L13-L29 |
13,608 | qlik-oss/enigma-go | float.go | MarshalJSON | func (value *Float64) MarshalJSON() ([]byte, error) {
val := float64(*value)
if math.IsNaN(val) {
return []byte(`"NaN"`), nil
} else if math.IsInf(val, 1) {
return []byte(`"Infinity"`), nil
} else if math.IsInf(val, -1) {
return []byte(`"-Infinity"`), nil
}
return json.Marshal(float64(*value))
} | go | func (value *Float64) MarshalJSON() ([]byte, error) {
val := float64(*value)
if math.IsNaN(val) {
return []byte(`"NaN"`), nil
} else if math.IsInf(val, 1) {
return []byte(`"Infinity"`), nil
} else if math.IsInf(val, -1) {
return []byte(`"-Infinity"`), nil
}
return json.Marshal(float64(*value))
} | [
"func",
"(",
"value",
"*",
"Float64",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"val",
":=",
"float64",
"(",
"*",
"value",
")",
"\n",
"if",
"math",
".",
"IsNaN",
"(",
"val",
")",
"{",
"return",
"[",
"]",
"byte",
"(",
"`\"NaN\"`",
")",
",",
"nil",
"\n",
"}",
"else",
"if",
"math",
".",
"IsInf",
"(",
"val",
",",
"1",
")",
"{",
"return",
"[",
"]",
"byte",
"(",
"`\"Infinity\"`",
")",
",",
"nil",
"\n",
"}",
"else",
"if",
"math",
".",
"IsInf",
"(",
"val",
",",
"-",
"1",
")",
"{",
"return",
"[",
"]",
"byte",
"(",
"`\"-Infinity\"`",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"json",
".",
"Marshal",
"(",
"float64",
"(",
"*",
"value",
")",
")",
"\n",
"}"
] | // MarshalJSON implements the Marshaler interface for custom marshalling. | [
"MarshalJSON",
"implements",
"the",
"Marshaler",
"interface",
"for",
"custom",
"marshalling",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/float.go#L32-L42 |
13,609 | qlik-oss/enigma-go | dialer.go | Dial | func (dialer Dialer) Dial(ctx context.Context, url string, httpHeader http.Header) (*Global, error) {
// Set empty http header if omitted
if httpHeader == nil {
httpHeader = make(http.Header, 0)
}
if dialer.MockMode {
dialer.CreateSocket = func(ctx context.Context, url string, httpHeader http.Header) (Socket, error) {
socket, err := NewMockSocket(dialer.TrafficDumpFile)
return socket, err
}
} else {
// Create default CreateSocket function if omitted
if dialer.CreateSocket == nil {
dialer.CreateSocket = func(ctx context.Context, url string, httpHeader http.Header) (Socket, error) {
gorillaDialer := websocket.Dialer{
TLSClientConfig: dialer.TLSClientConfig,
NetDial: func(network, addr string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, network, addr)
},
Jar: dialer.Jar,
}
// Run the actual websocket dialing (including the upgrade) in a goroutine so we can
// return if the context times out
chConn := make(chan *websocket.Conn, 1)
chErr := make(chan error, 1)
go func() {
conn, resp, err := gorillaDialer.Dial(url, httpHeader)
if err == websocket.ErrBadHandshake {
chErr <- errors.Wrapf(err, "%d from ws server", resp.StatusCode)
} else if err != nil {
chErr <- err
} else {
select {
case <-ctx.Done():
conn.Close()
default:
chConn <- conn
}
}
}()
select {
case <-ctx.Done():
return nil, errors.Wrapf(ctx.Err(), "error connecting to ws server %s", url)
case err := <-chErr:
return nil, err
case ws := <-chConn:
return ws, nil
}
}
}
if dialer.TrafficDumpFile != "" {
dialer.TrafficLogger = newFileTrafficLogger(dialer.TrafficDumpFile)
}
}
enigmaSession := newSession(&dialer)
err := enigmaSession.connect(ctx, url, httpHeader)
if err != nil {
return nil, err
}
return &Global{RemoteObject: enigmaSession.getRemoteObject(&ObjectInterface{Handle: -1, Type: "Global"})}, nil
} | go | func (dialer Dialer) Dial(ctx context.Context, url string, httpHeader http.Header) (*Global, error) {
// Set empty http header if omitted
if httpHeader == nil {
httpHeader = make(http.Header, 0)
}
if dialer.MockMode {
dialer.CreateSocket = func(ctx context.Context, url string, httpHeader http.Header) (Socket, error) {
socket, err := NewMockSocket(dialer.TrafficDumpFile)
return socket, err
}
} else {
// Create default CreateSocket function if omitted
if dialer.CreateSocket == nil {
dialer.CreateSocket = func(ctx context.Context, url string, httpHeader http.Header) (Socket, error) {
gorillaDialer := websocket.Dialer{
TLSClientConfig: dialer.TLSClientConfig,
NetDial: func(network, addr string) (net.Conn, error) {
return (&net.Dialer{}).DialContext(ctx, network, addr)
},
Jar: dialer.Jar,
}
// Run the actual websocket dialing (including the upgrade) in a goroutine so we can
// return if the context times out
chConn := make(chan *websocket.Conn, 1)
chErr := make(chan error, 1)
go func() {
conn, resp, err := gorillaDialer.Dial(url, httpHeader)
if err == websocket.ErrBadHandshake {
chErr <- errors.Wrapf(err, "%d from ws server", resp.StatusCode)
} else if err != nil {
chErr <- err
} else {
select {
case <-ctx.Done():
conn.Close()
default:
chConn <- conn
}
}
}()
select {
case <-ctx.Done():
return nil, errors.Wrapf(ctx.Err(), "error connecting to ws server %s", url)
case err := <-chErr:
return nil, err
case ws := <-chConn:
return ws, nil
}
}
}
if dialer.TrafficDumpFile != "" {
dialer.TrafficLogger = newFileTrafficLogger(dialer.TrafficDumpFile)
}
}
enigmaSession := newSession(&dialer)
err := enigmaSession.connect(ctx, url, httpHeader)
if err != nil {
return nil, err
}
return &Global{RemoteObject: enigmaSession.getRemoteObject(&ObjectInterface{Handle: -1, Type: "Global"})}, nil
} | [
"func",
"(",
"dialer",
"Dialer",
")",
"Dial",
"(",
"ctx",
"context",
".",
"Context",
",",
"url",
"string",
",",
"httpHeader",
"http",
".",
"Header",
")",
"(",
"*",
"Global",
",",
"error",
")",
"{",
"// Set empty http header if omitted",
"if",
"httpHeader",
"==",
"nil",
"{",
"httpHeader",
"=",
"make",
"(",
"http",
".",
"Header",
",",
"0",
")",
"\n",
"}",
"\n\n",
"if",
"dialer",
".",
"MockMode",
"{",
"dialer",
".",
"CreateSocket",
"=",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"url",
"string",
",",
"httpHeader",
"http",
".",
"Header",
")",
"(",
"Socket",
",",
"error",
")",
"{",
"socket",
",",
"err",
":=",
"NewMockSocket",
"(",
"dialer",
".",
"TrafficDumpFile",
")",
"\n",
"return",
"socket",
",",
"err",
"\n",
"}",
"\n",
"}",
"else",
"{",
"// Create default CreateSocket function if omitted",
"if",
"dialer",
".",
"CreateSocket",
"==",
"nil",
"{",
"dialer",
".",
"CreateSocket",
"=",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"url",
"string",
",",
"httpHeader",
"http",
".",
"Header",
")",
"(",
"Socket",
",",
"error",
")",
"{",
"gorillaDialer",
":=",
"websocket",
".",
"Dialer",
"{",
"TLSClientConfig",
":",
"dialer",
".",
"TLSClientConfig",
",",
"NetDial",
":",
"func",
"(",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"(",
"&",
"net",
".",
"Dialer",
"{",
"}",
")",
".",
"DialContext",
"(",
"ctx",
",",
"network",
",",
"addr",
")",
"\n",
"}",
",",
"Jar",
":",
"dialer",
".",
"Jar",
",",
"}",
"\n\n",
"// Run the actual websocket dialing (including the upgrade) in a goroutine so we can",
"// return if the context times out",
"chConn",
":=",
"make",
"(",
"chan",
"*",
"websocket",
".",
"Conn",
",",
"1",
")",
"\n",
"chErr",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"conn",
",",
"resp",
",",
"err",
":=",
"gorillaDialer",
".",
"Dial",
"(",
"url",
",",
"httpHeader",
")",
"\n",
"if",
"err",
"==",
"websocket",
".",
"ErrBadHandshake",
"{",
"chErr",
"<-",
"errors",
".",
"Wrapf",
"(",
"err",
",",
"\"",
"\"",
",",
"resp",
".",
"StatusCode",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"chErr",
"<-",
"err",
"\n",
"}",
"else",
"{",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"conn",
".",
"Close",
"(",
")",
"\n",
"default",
":",
"chConn",
"<-",
"conn",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"select",
"{",
"case",
"<-",
"ctx",
".",
"Done",
"(",
")",
":",
"return",
"nil",
",",
"errors",
".",
"Wrapf",
"(",
"ctx",
".",
"Err",
"(",
")",
",",
"\"",
"\"",
",",
"url",
")",
"\n",
"case",
"err",
":=",
"<-",
"chErr",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"ws",
":=",
"<-",
"chConn",
":",
"return",
"ws",
",",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"dialer",
".",
"TrafficDumpFile",
"!=",
"\"",
"\"",
"{",
"dialer",
".",
"TrafficLogger",
"=",
"newFileTrafficLogger",
"(",
"dialer",
".",
"TrafficDumpFile",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"enigmaSession",
":=",
"newSession",
"(",
"&",
"dialer",
")",
"\n",
"err",
":=",
"enigmaSession",
".",
"connect",
"(",
"ctx",
",",
"url",
",",
"httpHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Global",
"{",
"RemoteObject",
":",
"enigmaSession",
".",
"getRemoteObject",
"(",
"&",
"ObjectInterface",
"{",
"Handle",
":",
"-",
"1",
",",
"Type",
":",
"\"",
"\"",
"}",
")",
"}",
",",
"nil",
"\n",
"}"
] | // Dial establishes a connection to Qlik Associative Engine using the settings set in the Dialer. It takes two parameter | [
"Dial",
"establishes",
"a",
"connection",
"to",
"Qlik",
"Associative",
"Engine",
"using",
"the",
"settings",
"set",
"in",
"the",
"Dialer",
".",
"It",
"takes",
"two",
"parameter"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/dialer.go#L85-L148 |
13,610 | qlik-oss/enigma-go | metrics_collector.go | ToString | func (m *InvocationMetrics) ToString() string {
return fmt.Sprintf("On air time: %v, Total time: %v", m.SocketReadTimestamp.Sub(m.SocketWriteTimestamp), m.InvocationResponseTimestamp.Sub(m.InvocationRequestTimestamp))
} | go | func (m *InvocationMetrics) ToString() string {
return fmt.Sprintf("On air time: %v, Total time: %v", m.SocketReadTimestamp.Sub(m.SocketWriteTimestamp), m.InvocationResponseTimestamp.Sub(m.InvocationRequestTimestamp))
} | [
"func",
"(",
"m",
"*",
"InvocationMetrics",
")",
"ToString",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"SocketReadTimestamp",
".",
"Sub",
"(",
"m",
".",
"SocketWriteTimestamp",
")",
",",
"m",
".",
"InvocationResponseTimestamp",
".",
"Sub",
"(",
"m",
".",
"InvocationRequestTimestamp",
")",
")",
"\n",
"}"
] | // ToString returns a human-friendly string representation of elapsed times | [
"ToString",
"returns",
"a",
"human",
"-",
"friendly",
"string",
"representation",
"of",
"elapsed",
"times"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/metrics_collector.go#L31-L33 |
13,611 | qlik-oss/enigma-go | metrics_collector.go | Metrics | func (c *MetricsCollector) Metrics() *InvocationMetrics {
c.Lock()
defer c.Unlock()
return c.metrics
} | go | func (c *MetricsCollector) Metrics() *InvocationMetrics {
c.Lock()
defer c.Unlock()
return c.metrics
} | [
"func",
"(",
"c",
"*",
"MetricsCollector",
")",
"Metrics",
"(",
")",
"*",
"InvocationMetrics",
"{",
"c",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"Unlock",
"(",
")",
"\n",
"return",
"c",
".",
"metrics",
"\n",
"}"
] | // Metrics extracts performance information | [
"Metrics",
"extracts",
"performance",
"information"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/metrics_collector.go#L36-L40 |
13,612 | qlik-oss/enigma-go | metrics_collector.go | WithMetricsCollector | func WithMetricsCollector(ctx context.Context) (context.Context, *MetricsCollector) {
metricsCollector := &MetricsCollector{metrics: &InvocationMetrics{}}
ctxWithMetrics := context.WithValue(ctx, metricsCollectorID{}, metricsCollector)
return ctxWithMetrics, metricsCollector
} | go | func WithMetricsCollector(ctx context.Context) (context.Context, *MetricsCollector) {
metricsCollector := &MetricsCollector{metrics: &InvocationMetrics{}}
ctxWithMetrics := context.WithValue(ctx, metricsCollectorID{}, metricsCollector)
return ctxWithMetrics, metricsCollector
} | [
"func",
"WithMetricsCollector",
"(",
"ctx",
"context",
".",
"Context",
")",
"(",
"context",
".",
"Context",
",",
"*",
"MetricsCollector",
")",
"{",
"metricsCollector",
":=",
"&",
"MetricsCollector",
"{",
"metrics",
":",
"&",
"InvocationMetrics",
"{",
"}",
"}",
"\n",
"ctxWithMetrics",
":=",
"context",
".",
"WithValue",
"(",
"ctx",
",",
"metricsCollectorID",
"{",
"}",
",",
"metricsCollector",
")",
"\n",
"return",
"ctxWithMetrics",
",",
"metricsCollector",
"\n",
"}"
] | // WithMetricsCollector provides a new context with the a MetricsCollector that records performance metrics for invocations | [
"WithMetricsCollector",
"provides",
"a",
"new",
"context",
"with",
"the",
"a",
"MetricsCollector",
"that",
"records",
"performance",
"metrics",
"for",
"invocations"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/metrics_collector.go#L51-L55 |
13,613 | qlik-oss/enigma-go | examples/interceptors/metrics/metrics.go | metricsInterceptor | func metricsInterceptor(ctx context.Context, invocation *enigma.Invocation, proceed enigma.InterceptorContinuation) *enigma.InvocationResponse {
ctxWithMetrics, metricsCollector := enigma.WithMetricsCollector(ctx)
response := proceed(ctxWithMetrics, invocation)
metrics := metricsCollector.Metrics()
fmt.Println(response.RequestID, invocation.RemoteObject.Type, invocation.Method, metrics.ToString())
return response
} | go | func metricsInterceptor(ctx context.Context, invocation *enigma.Invocation, proceed enigma.InterceptorContinuation) *enigma.InvocationResponse {
ctxWithMetrics, metricsCollector := enigma.WithMetricsCollector(ctx)
response := proceed(ctxWithMetrics, invocation)
metrics := metricsCollector.Metrics()
fmt.Println(response.RequestID, invocation.RemoteObject.Type, invocation.Method, metrics.ToString())
return response
} | [
"func",
"metricsInterceptor",
"(",
"ctx",
"context",
".",
"Context",
",",
"invocation",
"*",
"enigma",
".",
"Invocation",
",",
"proceed",
"enigma",
".",
"InterceptorContinuation",
")",
"*",
"enigma",
".",
"InvocationResponse",
"{",
"ctxWithMetrics",
",",
"metricsCollector",
":=",
"enigma",
".",
"WithMetricsCollector",
"(",
"ctx",
")",
"\n\n",
"response",
":=",
"proceed",
"(",
"ctxWithMetrics",
",",
"invocation",
")",
"\n\n",
"metrics",
":=",
"metricsCollector",
".",
"Metrics",
"(",
")",
"\n",
"fmt",
".",
"Println",
"(",
"response",
".",
"RequestID",
",",
"invocation",
".",
"RemoteObject",
".",
"Type",
",",
"invocation",
".",
"Method",
",",
"metrics",
".",
"ToString",
"(",
")",
")",
"\n",
"return",
"response",
"\n",
"}"
] | // MetricsInterceptor shows how to an interceptor that collects metrics data can be written. | [
"MetricsInterceptor",
"shows",
"how",
"to",
"an",
"interceptor",
"that",
"collects",
"metrics",
"data",
"can",
"be",
"written",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/examples/interceptors/metrics/metrics.go#L38-L46 |
13,614 | qlik-oss/enigma-go | websocket_mock.go | ExpectCall | func (t *MockSocket) ExpectCall(request string, response string) {
t.expectedRequests <- &mocksocketRequest{sentMessage: json.RawMessage(request), responses: []json.RawMessage{json.RawMessage(response)}}
} | go | func (t *MockSocket) ExpectCall(request string, response string) {
t.expectedRequests <- &mocksocketRequest{sentMessage: json.RawMessage(request), responses: []json.RawMessage{json.RawMessage(response)}}
} | [
"func",
"(",
"t",
"*",
"MockSocket",
")",
"ExpectCall",
"(",
"request",
"string",
",",
"response",
"string",
")",
"{",
"t",
".",
"expectedRequests",
"<-",
"&",
"mocksocketRequest",
"{",
"sentMessage",
":",
"json",
".",
"RawMessage",
"(",
"request",
")",
",",
"responses",
":",
"[",
"]",
"json",
".",
"RawMessage",
"{",
"json",
".",
"RawMessage",
"(",
"response",
")",
"}",
"}",
"\n",
"}"
] | // ExpectCall sets a response message given a request message. | [
"ExpectCall",
"sets",
"a",
"response",
"message",
"given",
"a",
"request",
"message",
"."
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L33-L35 |
13,615 | qlik-oss/enigma-go | websocket_mock.go | AddReceivedMessage | func (t *MockSocket) AddReceivedMessage(response string) {
t.receivedMessages <- json.RawMessage(response)
} | go | func (t *MockSocket) AddReceivedMessage(response string) {
t.receivedMessages <- json.RawMessage(response)
} | [
"func",
"(",
"t",
"*",
"MockSocket",
")",
"AddReceivedMessage",
"(",
"response",
"string",
")",
"{",
"t",
".",
"receivedMessages",
"<-",
"json",
".",
"RawMessage",
"(",
"response",
")",
"\n",
"}"
] | // AddReceivedMessage adds a message to the received message queue immediately | [
"AddReceivedMessage",
"adds",
"a",
"message",
"to",
"the",
"received",
"message",
"queue",
"immediately"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L38-L40 |
13,616 | qlik-oss/enigma-go | websocket_mock.go | WriteMessage | func (t *MockSocket) WriteMessage(messageType int, message []byte) error {
select {
case expectedMessage := <-t.expectedRequests:
if asCanonicalString(expectedMessage.sentMessage) == asCanonicalString(message) {
// Transfer the response into the received messages channel
for _, response := range expectedMessage.responses {
t.receivedMessages <- response
}
} else {
fmt.Println("Unexpected response", asCanonicalString(message))
fmt.Println("Expected ", string(expectedMessage.sentMessage))
}
default:
fmt.Println("No more responses registered, expecting", string(message))
}
return nil
} | go | func (t *MockSocket) WriteMessage(messageType int, message []byte) error {
select {
case expectedMessage := <-t.expectedRequests:
if asCanonicalString(expectedMessage.sentMessage) == asCanonicalString(message) {
// Transfer the response into the received messages channel
for _, response := range expectedMessage.responses {
t.receivedMessages <- response
}
} else {
fmt.Println("Unexpected response", asCanonicalString(message))
fmt.Println("Expected ", string(expectedMessage.sentMessage))
}
default:
fmt.Println("No more responses registered, expecting", string(message))
}
return nil
} | [
"func",
"(",
"t",
"*",
"MockSocket",
")",
"WriteMessage",
"(",
"messageType",
"int",
",",
"message",
"[",
"]",
"byte",
")",
"error",
"{",
"select",
"{",
"case",
"expectedMessage",
":=",
"<-",
"t",
".",
"expectedRequests",
":",
"if",
"asCanonicalString",
"(",
"expectedMessage",
".",
"sentMessage",
")",
"==",
"asCanonicalString",
"(",
"message",
")",
"{",
"// Transfer the response into the received messages channel",
"for",
"_",
",",
"response",
":=",
"range",
"expectedMessage",
".",
"responses",
"{",
"t",
".",
"receivedMessages",
"<-",
"response",
"\n",
"}",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"asCanonicalString",
"(",
"message",
")",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"string",
"(",
"expectedMessage",
".",
"sentMessage",
")",
")",
"\n",
"}",
"\n",
"default",
":",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"string",
"(",
"message",
")",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // WriteMessage implements the Socket interface | [
"WriteMessage",
"implements",
"the",
"Socket",
"interface"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L43-L60 |
13,617 | qlik-oss/enigma-go | websocket_mock.go | ReadMessage | func (t *MockSocket) ReadMessage() (int, []byte, error) {
message, isOpen := <-t.receivedMessages
if !isOpen {
return 0, nil, errors.New("socket closed by test case")
}
return 1, message, nil
} | go | func (t *MockSocket) ReadMessage() (int, []byte, error) {
message, isOpen := <-t.receivedMessages
if !isOpen {
return 0, nil, errors.New("socket closed by test case")
}
return 1, message, nil
} | [
"func",
"(",
"t",
"*",
"MockSocket",
")",
"ReadMessage",
"(",
")",
"(",
"int",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"message",
",",
"isOpen",
":=",
"<-",
"t",
".",
"receivedMessages",
"\n",
"if",
"!",
"isOpen",
"{",
"return",
"0",
",",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"1",
",",
"message",
",",
"nil",
"\n",
"}"
] | // ReadMessage implements the Socket interface | [
"ReadMessage",
"implements",
"the",
"Socket",
"interface"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L63-L69 |
13,618 | qlik-oss/enigma-go | websocket_mock.go | Close | func (t *MockSocket) Close() error {
select {
case <-t.closed:
// Do nothing
default:
close(t.closed)
close(t.expectedRequests)
close(t.receivedMessages)
}
return nil
} | go | func (t *MockSocket) Close() error {
select {
case <-t.closed:
// Do nothing
default:
close(t.closed)
close(t.expectedRequests)
close(t.receivedMessages)
}
return nil
} | [
"func",
"(",
"t",
"*",
"MockSocket",
")",
"Close",
"(",
")",
"error",
"{",
"select",
"{",
"case",
"<-",
"t",
".",
"closed",
":",
"// Do nothing",
"default",
":",
"close",
"(",
"t",
".",
"closed",
")",
"\n",
"close",
"(",
"t",
".",
"expectedRequests",
")",
"\n",
"close",
"(",
"t",
".",
"receivedMessages",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Close implements the Socket interface | [
"Close",
"implements",
"the",
"Socket",
"interface"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L72-L82 |
13,619 | qlik-oss/enigma-go | websocket_mock.go | NewMockSocket | func NewMockSocket(fileName string) (*MockSocket, error) {
socket := &MockSocket{receivedMessages: make(chan json.RawMessage, 100), expectedRequests: make(chan *mocksocketRequest, 10000), closed: make(chan struct{})}
if fileName != "" {
var lastRequest *mocksocketRequest
messages := readTrafficLog(fileName)
for _, m := range messages {
if m.Sent != nil {
lastRequest = &mocksocketRequest{sentMessage: m.Sent}
socket.expectedRequests <- lastRequest
} else if m.Received != nil {
if lastRequest == nil {
// When no request have been sent then push the received messages straight to the receivedMessage channel
socket.receivedMessages <- m.Received
} else {
// When a request has been sent then add the responses to that request
lastRequest.responses = append(lastRequest.responses, m.Received)
}
}
}
}
return socket, nil
} | go | func NewMockSocket(fileName string) (*MockSocket, error) {
socket := &MockSocket{receivedMessages: make(chan json.RawMessage, 100), expectedRequests: make(chan *mocksocketRequest, 10000), closed: make(chan struct{})}
if fileName != "" {
var lastRequest *mocksocketRequest
messages := readTrafficLog(fileName)
for _, m := range messages {
if m.Sent != nil {
lastRequest = &mocksocketRequest{sentMessage: m.Sent}
socket.expectedRequests <- lastRequest
} else if m.Received != nil {
if lastRequest == nil {
// When no request have been sent then push the received messages straight to the receivedMessage channel
socket.receivedMessages <- m.Received
} else {
// When a request has been sent then add the responses to that request
lastRequest.responses = append(lastRequest.responses, m.Received)
}
}
}
}
return socket, nil
} | [
"func",
"NewMockSocket",
"(",
"fileName",
"string",
")",
"(",
"*",
"MockSocket",
",",
"error",
")",
"{",
"socket",
":=",
"&",
"MockSocket",
"{",
"receivedMessages",
":",
"make",
"(",
"chan",
"json",
".",
"RawMessage",
",",
"100",
")",
",",
"expectedRequests",
":",
"make",
"(",
"chan",
"*",
"mocksocketRequest",
",",
"10000",
")",
",",
"closed",
":",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"}",
"\n",
"if",
"fileName",
"!=",
"\"",
"\"",
"{",
"var",
"lastRequest",
"*",
"mocksocketRequest",
"\n",
"messages",
":=",
"readTrafficLog",
"(",
"fileName",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"messages",
"{",
"if",
"m",
".",
"Sent",
"!=",
"nil",
"{",
"lastRequest",
"=",
"&",
"mocksocketRequest",
"{",
"sentMessage",
":",
"m",
".",
"Sent",
"}",
"\n",
"socket",
".",
"expectedRequests",
"<-",
"lastRequest",
"\n",
"}",
"else",
"if",
"m",
".",
"Received",
"!=",
"nil",
"{",
"if",
"lastRequest",
"==",
"nil",
"{",
"// When no request have been sent then push the received messages straight to the receivedMessage channel",
"socket",
".",
"receivedMessages",
"<-",
"m",
".",
"Received",
"\n",
"}",
"else",
"{",
"// When a request has been sent then add the responses to that request",
"lastRequest",
".",
"responses",
"=",
"append",
"(",
"lastRequest",
".",
"responses",
",",
"m",
".",
"Received",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"socket",
",",
"nil",
"\n",
"}"
] | // NewMockSocket creates a new MockSocket instance | [
"NewMockSocket",
"creates",
"a",
"new",
"MockSocket",
"instance"
] | 7fdea27298e888663c973c15dbbfba2c0a1ec085 | https://github.com/qlik-oss/enigma-go/blob/7fdea27298e888663c973c15dbbfba2c0a1ec085/websocket_mock.go#L85-L107 |
13,620 | kolo/xmlrpc | client.go | NewClient | func NewClient(requrl string, transport http.RoundTripper) (*Client, error) {
if transport == nil {
transport = http.DefaultTransport
}
httpClient := &http.Client{Transport: transport}
jar, err := cookiejar.New(nil)
if err != nil {
return nil, err
}
u, err := url.Parse(requrl)
if err != nil {
return nil, err
}
codec := clientCodec{
url: u,
httpClient: httpClient,
close: make(chan uint64),
ready: make(chan uint64),
responses: make(map[uint64]*http.Response),
cookies: jar,
}
return &Client{rpc.NewClientWithCodec(&codec)}, nil
} | go | func NewClient(requrl string, transport http.RoundTripper) (*Client, error) {
if transport == nil {
transport = http.DefaultTransport
}
httpClient := &http.Client{Transport: transport}
jar, err := cookiejar.New(nil)
if err != nil {
return nil, err
}
u, err := url.Parse(requrl)
if err != nil {
return nil, err
}
codec := clientCodec{
url: u,
httpClient: httpClient,
close: make(chan uint64),
ready: make(chan uint64),
responses: make(map[uint64]*http.Response),
cookies: jar,
}
return &Client{rpc.NewClientWithCodec(&codec)}, nil
} | [
"func",
"NewClient",
"(",
"requrl",
"string",
",",
"transport",
"http",
".",
"RoundTripper",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"if",
"transport",
"==",
"nil",
"{",
"transport",
"=",
"http",
".",
"DefaultTransport",
"\n",
"}",
"\n\n",
"httpClient",
":=",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"transport",
"}",
"\n\n",
"jar",
",",
"err",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"requrl",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"codec",
":=",
"clientCodec",
"{",
"url",
":",
"u",
",",
"httpClient",
":",
"httpClient",
",",
"close",
":",
"make",
"(",
"chan",
"uint64",
")",
",",
"ready",
":",
"make",
"(",
"chan",
"uint64",
")",
",",
"responses",
":",
"make",
"(",
"map",
"[",
"uint64",
"]",
"*",
"http",
".",
"Response",
")",
",",
"cookies",
":",
"jar",
",",
"}",
"\n\n",
"return",
"&",
"Client",
"{",
"rpc",
".",
"NewClientWithCodec",
"(",
"&",
"codec",
")",
"}",
",",
"nil",
"\n",
"}"
] | // NewClient returns instance of rpc.Client object, that is used to send request to xmlrpc service. | [
"NewClient",
"returns",
"instance",
"of",
"rpc",
".",
"Client",
"object",
"that",
"is",
"used",
"to",
"send",
"request",
"to",
"xmlrpc",
"service",
"."
] | de6d879202d7d642e74d3a70d4e9d560f252cb22 | https://github.com/kolo/xmlrpc/blob/de6d879202d7d642e74d3a70d4e9d560f252cb22/client.go#L141-L170 |
13,621 | zach-klippenstein/goadb | dir_entries.go | ReadAll | func (entries *DirEntries) ReadAll() (result []*DirEntry, err error) {
defer entries.Close()
for entries.Next() {
result = append(result, entries.Entry())
}
err = entries.Err()
return
} | go | func (entries *DirEntries) ReadAll() (result []*DirEntry, err error) {
defer entries.Close()
for entries.Next() {
result = append(result, entries.Entry())
}
err = entries.Err()
return
} | [
"func",
"(",
"entries",
"*",
"DirEntries",
")",
"ReadAll",
"(",
")",
"(",
"result",
"[",
"]",
"*",
"DirEntry",
",",
"err",
"error",
")",
"{",
"defer",
"entries",
".",
"Close",
"(",
")",
"\n\n",
"for",
"entries",
".",
"Next",
"(",
")",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"entries",
".",
"Entry",
"(",
")",
")",
"\n",
"}",
"\n",
"err",
"=",
"entries",
".",
"Err",
"(",
")",
"\n\n",
"return",
"\n",
"}"
] | // ReadAllDirEntries reads all the remaining directory entries into a slice,
// closes self, and returns any error.
// If err is non-nil, result will contain any entries read until the error occurred. | [
"ReadAllDirEntries",
"reads",
"all",
"the",
"remaining",
"directory",
"entries",
"into",
"a",
"slice",
"closes",
"self",
"and",
"returns",
"any",
"error",
".",
"If",
"err",
"is",
"non",
"-",
"nil",
"result",
"will",
"contain",
"any",
"entries",
"read",
"until",
"the",
"error",
"occurred",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/dir_entries.go#L30-L39 |
13,622 | zach-klippenstein/goadb | wire/sync_conn.go | Close | func (c SyncConn) Close() error {
return errors.CombineErrs("error closing SyncConn", errors.NetworkError,
c.SyncScanner.Close(), c.SyncSender.Close())
} | go | func (c SyncConn) Close() error {
return errors.CombineErrs("error closing SyncConn", errors.NetworkError,
c.SyncScanner.Close(), c.SyncSender.Close())
} | [
"func",
"(",
"c",
"SyncConn",
")",
"Close",
"(",
")",
"error",
"{",
"return",
"errors",
".",
"CombineErrs",
"(",
"\"",
"\"",
",",
"errors",
".",
"NetworkError",
",",
"c",
".",
"SyncScanner",
".",
"Close",
"(",
")",
",",
"c",
".",
"SyncSender",
".",
"Close",
"(",
")",
")",
"\n",
"}"
] | // Close closes both the sender and the scanner, and returns any errors. | [
"Close",
"closes",
"both",
"the",
"sender",
"and",
"the",
"scanner",
"and",
"returns",
"any",
"errors",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/wire/sync_conn.go#L34-L37 |
13,623 | zach-klippenstein/goadb | wire/conn.go | RoundTripSingleResponse | func (conn *Conn) RoundTripSingleResponse(req []byte) (resp []byte, err error) {
if err = conn.SendMessage(req); err != nil {
return nil, err
}
if _, err = conn.ReadStatus(string(req)); err != nil {
return nil, err
}
return conn.ReadMessage()
} | go | func (conn *Conn) RoundTripSingleResponse(req []byte) (resp []byte, err error) {
if err = conn.SendMessage(req); err != nil {
return nil, err
}
if _, err = conn.ReadStatus(string(req)); err != nil {
return nil, err
}
return conn.ReadMessage()
} | [
"func",
"(",
"conn",
"*",
"Conn",
")",
"RoundTripSingleResponse",
"(",
"req",
"[",
"]",
"byte",
")",
"(",
"resp",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"if",
"err",
"=",
"conn",
".",
"SendMessage",
"(",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"conn",
".",
"ReadStatus",
"(",
"string",
"(",
"req",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"conn",
".",
"ReadMessage",
"(",
")",
"\n",
"}"
] | // RoundTripSingleResponse sends a message to the server, and reads a single
// message response. If the reponse has a failure status code, returns it as an error. | [
"RoundTripSingleResponse",
"sends",
"a",
"message",
"to",
"the",
"server",
"and",
"reads",
"a",
"single",
"message",
"response",
".",
"If",
"the",
"reponse",
"has",
"a",
"failure",
"status",
"code",
"returns",
"it",
"as",
"an",
"error",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/wire/conn.go#L53-L63 |
13,624 | zach-klippenstein/goadb | device_watcher.go | CameOnline | func (s DeviceStateChangedEvent) CameOnline() bool {
return s.OldState != StateOnline && s.NewState == StateOnline
} | go | func (s DeviceStateChangedEvent) CameOnline() bool {
return s.OldState != StateOnline && s.NewState == StateOnline
} | [
"func",
"(",
"s",
"DeviceStateChangedEvent",
")",
"CameOnline",
"(",
")",
"bool",
"{",
"return",
"s",
".",
"OldState",
"!=",
"StateOnline",
"&&",
"s",
".",
"NewState",
"==",
"StateOnline",
"\n",
"}"
] | // CameOnline returns true if this event represents a device coming online. | [
"CameOnline",
"returns",
"true",
"if",
"this",
"event",
"represents",
"a",
"device",
"coming",
"online",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device_watcher.go#L33-L35 |
13,625 | zach-klippenstein/goadb | device_watcher.go | WentOffline | func (s DeviceStateChangedEvent) WentOffline() bool {
return s.OldState == StateOnline && s.NewState != StateOnline
} | go | func (s DeviceStateChangedEvent) WentOffline() bool {
return s.OldState == StateOnline && s.NewState != StateOnline
} | [
"func",
"(",
"s",
"DeviceStateChangedEvent",
")",
"WentOffline",
"(",
")",
"bool",
"{",
"return",
"s",
".",
"OldState",
"==",
"StateOnline",
"&&",
"s",
".",
"NewState",
"!=",
"StateOnline",
"\n",
"}"
] | // WentOffline returns true if this event represents a device going offline. | [
"WentOffline",
"returns",
"true",
"if",
"this",
"event",
"represents",
"a",
"device",
"going",
"offline",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device_watcher.go#L38-L40 |
13,626 | zach-klippenstein/goadb | device_watcher.go | Err | func (w *DeviceWatcher) Err() error {
if err, ok := w.err.Load().(error); ok {
return err
}
return nil
} | go | func (w *DeviceWatcher) Err() error {
if err, ok := w.err.Load().(error); ok {
return err
}
return nil
} | [
"func",
"(",
"w",
"*",
"DeviceWatcher",
")",
"Err",
"(",
")",
"error",
"{",
"if",
"err",
",",
"ok",
":=",
"w",
".",
"err",
".",
"Load",
"(",
")",
".",
"(",
"error",
")",
";",
"ok",
"{",
"return",
"err",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Err returns the error that caused the channel returned by C to be closed, if C is closed.
// If C is not closed, its return value is undefined. | [
"Err",
"returns",
"the",
"error",
"that",
"caused",
"the",
"channel",
"returned",
"by",
"C",
"to",
"be",
"closed",
"if",
"C",
"is",
"closed",
".",
"If",
"C",
"is",
"not",
"closed",
"its",
"return",
"value",
"is",
"undefined",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device_watcher.go#L76-L81 |
13,627 | zach-klippenstein/goadb | adb.go | ServerVersion | func (c *Adb) ServerVersion() (int, error) {
resp, err := roundTripSingleResponse(c.server, "host:version")
if err != nil {
return 0, wrapClientError(err, c, "GetServerVersion")
}
version, err := c.parseServerVersion(resp)
if err != nil {
return 0, wrapClientError(err, c, "GetServerVersion")
}
return version, nil
} | go | func (c *Adb) ServerVersion() (int, error) {
resp, err := roundTripSingleResponse(c.server, "host:version")
if err != nil {
return 0, wrapClientError(err, c, "GetServerVersion")
}
version, err := c.parseServerVersion(resp)
if err != nil {
return 0, wrapClientError(err, c, "GetServerVersion")
}
return version, nil
} | [
"func",
"(",
"c",
"*",
"Adb",
")",
"ServerVersion",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"resp",
",",
"err",
":=",
"roundTripSingleResponse",
"(",
"c",
".",
"server",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"wrapClientError",
"(",
"err",
",",
"c",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"version",
",",
"err",
":=",
"c",
".",
"parseServerVersion",
"(",
"resp",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"wrapClientError",
"(",
"err",
",",
"c",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"version",
",",
"nil",
"\n",
"}"
] | // ServerVersion asks the ADB server for its internal version number. | [
"ServerVersion",
"asks",
"the",
"ADB",
"server",
"for",
"its",
"internal",
"version",
"number",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/adb.go#L60-L71 |
13,628 | zach-klippenstein/goadb | wire/scanner.go | readStatusFailureAsError | func readStatusFailureAsError(r io.Reader, req string, messageLengthReader lengthReader) (string, error) {
status, err := readOctetString(req, r)
if err != nil {
return "", errors.WrapErrorf(err, errors.NetworkError, "error reading status for %s", req)
}
if isFailureStatus(status) {
msg, err := readMessage(r, messageLengthReader)
if err != nil {
return "", errors.WrapErrorf(err, errors.NetworkError,
"server returned error for %s, but couldn't read the error message", req)
}
return "", adbServerError(req, string(msg))
}
return status, nil
} | go | func readStatusFailureAsError(r io.Reader, req string, messageLengthReader lengthReader) (string, error) {
status, err := readOctetString(req, r)
if err != nil {
return "", errors.WrapErrorf(err, errors.NetworkError, "error reading status for %s", req)
}
if isFailureStatus(status) {
msg, err := readMessage(r, messageLengthReader)
if err != nil {
return "", errors.WrapErrorf(err, errors.NetworkError,
"server returned error for %s, but couldn't read the error message", req)
}
return "", adbServerError(req, string(msg))
}
return status, nil
} | [
"func",
"readStatusFailureAsError",
"(",
"r",
"io",
".",
"Reader",
",",
"req",
"string",
",",
"messageLengthReader",
"lengthReader",
")",
"(",
"string",
",",
"error",
")",
"{",
"status",
",",
"err",
":=",
"readOctetString",
"(",
"req",
",",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"WrapErrorf",
"(",
"err",
",",
"errors",
".",
"NetworkError",
",",
"\"",
"\"",
",",
"req",
")",
"\n",
"}",
"\n\n",
"if",
"isFailureStatus",
"(",
"status",
")",
"{",
"msg",
",",
"err",
":=",
"readMessage",
"(",
"r",
",",
"messageLengthReader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"WrapErrorf",
"(",
"err",
",",
"errors",
".",
"NetworkError",
",",
"\"",
"\"",
",",
"req",
")",
"\n",
"}",
"\n\n",
"return",
"\"",
"\"",
",",
"adbServerError",
"(",
"req",
",",
"string",
"(",
"msg",
")",
")",
"\n",
"}",
"\n\n",
"return",
"status",
",",
"nil",
"\n",
"}"
] | // Reads the status, and if failure, reads the message and returns it as an error.
// If the status is success, doesn't read the message.
// req is just used to populate the AdbError, and can be nil.
// messageLengthReader is the function passed to readMessage if the status is failure. | [
"Reads",
"the",
"status",
"and",
"if",
"failure",
"reads",
"the",
"message",
"and",
"returns",
"it",
"as",
"an",
"error",
".",
"If",
"the",
"status",
"is",
"success",
"doesn",
"t",
"read",
"the",
"message",
".",
"req",
"is",
"just",
"used",
"to",
"populate",
"the",
"AdbError",
"and",
"can",
"be",
"nil",
".",
"messageLengthReader",
"is",
"the",
"function",
"passed",
"to",
"readMessage",
"if",
"the",
"status",
"is",
"failure",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/wire/scanner.go#L98-L115 |
13,629 | zach-klippenstein/goadb | wire/scanner.go | readHexLength | func readHexLength(r io.Reader) (int, error) {
lengthHex := make([]byte, 4)
n, err := io.ReadFull(r, lengthHex)
if err != nil {
return 0, errIncompleteMessage("length", n, 4)
}
length, err := strconv.ParseInt(string(lengthHex), 16, 64)
if err != nil {
return 0, errors.WrapErrorf(err, errors.NetworkError, "could not parse hex length %v", lengthHex)
}
// Clip the length to 255, as per the Google implementation.
if length > MaxMessageLength {
length = MaxMessageLength
}
return int(length), nil
} | go | func readHexLength(r io.Reader) (int, error) {
lengthHex := make([]byte, 4)
n, err := io.ReadFull(r, lengthHex)
if err != nil {
return 0, errIncompleteMessage("length", n, 4)
}
length, err := strconv.ParseInt(string(lengthHex), 16, 64)
if err != nil {
return 0, errors.WrapErrorf(err, errors.NetworkError, "could not parse hex length %v", lengthHex)
}
// Clip the length to 255, as per the Google implementation.
if length > MaxMessageLength {
length = MaxMessageLength
}
return int(length), nil
} | [
"func",
"readHexLength",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"error",
")",
"{",
"lengthHex",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4",
")",
"\n",
"n",
",",
"err",
":=",
"io",
".",
"ReadFull",
"(",
"r",
",",
"lengthHex",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"errIncompleteMessage",
"(",
"\"",
"\"",
",",
"n",
",",
"4",
")",
"\n",
"}",
"\n\n",
"length",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"string",
"(",
"lengthHex",
")",
",",
"16",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"errors",
".",
"WrapErrorf",
"(",
"err",
",",
"errors",
".",
"NetworkError",
",",
"\"",
"\"",
",",
"lengthHex",
")",
"\n",
"}",
"\n\n",
"// Clip the length to 255, as per the Google implementation.",
"if",
"length",
">",
"MaxMessageLength",
"{",
"length",
"=",
"MaxMessageLength",
"\n",
"}",
"\n\n",
"return",
"int",
"(",
"length",
")",
",",
"nil",
"\n",
"}"
] | // readHexLength reads the next 4 bytes from r as an ASCII hex-encoded length and parses them into an int. | [
"readHexLength",
"reads",
"the",
"next",
"4",
"bytes",
"from",
"r",
"as",
"an",
"ASCII",
"hex",
"-",
"encoded",
"length",
"and",
"parses",
"them",
"into",
"an",
"int",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/wire/scanner.go#L154-L172 |
13,630 | zach-klippenstein/goadb | wire/scanner.go | readInt32 | func readInt32(r io.Reader) (int, error) {
var value int32
err := binary.Read(r, binary.LittleEndian, &value)
return int(value), err
} | go | func readInt32(r io.Reader) (int, error) {
var value int32
err := binary.Read(r, binary.LittleEndian, &value)
return int(value), err
} | [
"func",
"readInt32",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"error",
")",
"{",
"var",
"value",
"int32",
"\n",
"err",
":=",
"binary",
".",
"Read",
"(",
"r",
",",
"binary",
".",
"LittleEndian",
",",
"&",
"value",
")",
"\n",
"return",
"int",
"(",
"value",
")",
",",
"err",
"\n",
"}"
] | // readInt32 reads the next 4 bytes from r as a little-endian integer.
// Returns an int instead of an int32 to match the lengthReader type. | [
"readInt32",
"reads",
"the",
"next",
"4",
"bytes",
"from",
"r",
"as",
"a",
"little",
"-",
"endian",
"integer",
".",
"Returns",
"an",
"int",
"instead",
"of",
"an",
"int32",
"to",
"match",
"the",
"lengthReader",
"type",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/wire/scanner.go#L176-L180 |
13,631 | zach-klippenstein/goadb | server.go | Dial | func (s *realServer) Dial() (*wire.Conn, error) {
conn, err := s.config.Dial(s.address)
if err != nil {
// Attempt to start the server and try again.
if err = s.Start(); err != nil {
return nil, errors.WrapErrorf(err, errors.ServerNotAvailable, "error starting server for dial")
}
conn, err = s.config.Dial(s.address)
if err != nil {
return nil, err
}
}
return conn, nil
} | go | func (s *realServer) Dial() (*wire.Conn, error) {
conn, err := s.config.Dial(s.address)
if err != nil {
// Attempt to start the server and try again.
if err = s.Start(); err != nil {
return nil, errors.WrapErrorf(err, errors.ServerNotAvailable, "error starting server for dial")
}
conn, err = s.config.Dial(s.address)
if err != nil {
return nil, err
}
}
return conn, nil
} | [
"func",
"(",
"s",
"*",
"realServer",
")",
"Dial",
"(",
")",
"(",
"*",
"wire",
".",
"Conn",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"s",
".",
"config",
".",
"Dial",
"(",
"s",
".",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Attempt to start the server and try again.",
"if",
"err",
"=",
"s",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"WrapErrorf",
"(",
"err",
",",
"errors",
".",
"ServerNotAvailable",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
"=",
"s",
".",
"config",
".",
"Dial",
"(",
"s",
".",
"address",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // Dial tries to connect to the server. If the first attempt fails, tries starting the server before
// retrying. If the second attempt fails, returns the error. | [
"Dial",
"tries",
"to",
"connect",
"to",
"the",
"server",
".",
"If",
"the",
"first",
"attempt",
"fails",
"tries",
"starting",
"the",
"server",
"before",
"retrying",
".",
"If",
"the",
"second",
"attempt",
"fails",
"returns",
"the",
"error",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/server.go#L94-L108 |
13,632 | zach-klippenstein/goadb | server.go | Start | func (s *realServer) Start() error {
output, err := s.config.fs.CmdCombinedOutput(s.config.PathToAdb, "-L", fmt.Sprintf("tcp:%s", s.address), "start-server")
outputStr := strings.TrimSpace(string(output))
return errors.WrapErrorf(err, errors.ServerNotAvailable, "error starting server: %s\noutput:\n%s", err, outputStr)
} | go | func (s *realServer) Start() error {
output, err := s.config.fs.CmdCombinedOutput(s.config.PathToAdb, "-L", fmt.Sprintf("tcp:%s", s.address), "start-server")
outputStr := strings.TrimSpace(string(output))
return errors.WrapErrorf(err, errors.ServerNotAvailable, "error starting server: %s\noutput:\n%s", err, outputStr)
} | [
"func",
"(",
"s",
"*",
"realServer",
")",
"Start",
"(",
")",
"error",
"{",
"output",
",",
"err",
":=",
"s",
".",
"config",
".",
"fs",
".",
"CmdCombinedOutput",
"(",
"s",
".",
"config",
".",
"PathToAdb",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"s",
".",
"address",
")",
",",
"\"",
"\"",
")",
"\n",
"outputStr",
":=",
"strings",
".",
"TrimSpace",
"(",
"string",
"(",
"output",
")",
")",
"\n",
"return",
"errors",
".",
"WrapErrorf",
"(",
"err",
",",
"errors",
".",
"ServerNotAvailable",
",",
"\"",
"\\n",
"\\n",
"\"",
",",
"err",
",",
"outputStr",
")",
"\n",
"}"
] | // StartServer ensures there is a server running. | [
"StartServer",
"ensures",
"there",
"is",
"a",
"server",
"running",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/server.go#L111-L115 |
13,633 | zach-klippenstein/goadb | sync_file_reader.go | readNextChunk | func readNextChunk(r wire.SyncScanner) (io.Reader, error) {
status, err := r.ReadStatus("read-chunk")
if err != nil {
if wire.IsAdbServerErrorMatching(err, readFileNotFoundPredicate) {
return nil, errors.Errorf(errors.FileNoExistError, "no such file or directory")
}
return nil, err
}
switch status {
case wire.StatusSyncData:
return r.ReadBytes()
case wire.StatusSyncDone:
return nil, io.EOF
default:
return nil, errors.Errorf(errors.AssertionError, "expected chunk id '%s' or '%s', but got '%s'",
wire.StatusSyncData, wire.StatusSyncDone, []byte(status))
}
} | go | func readNextChunk(r wire.SyncScanner) (io.Reader, error) {
status, err := r.ReadStatus("read-chunk")
if err != nil {
if wire.IsAdbServerErrorMatching(err, readFileNotFoundPredicate) {
return nil, errors.Errorf(errors.FileNoExistError, "no such file or directory")
}
return nil, err
}
switch status {
case wire.StatusSyncData:
return r.ReadBytes()
case wire.StatusSyncDone:
return nil, io.EOF
default:
return nil, errors.Errorf(errors.AssertionError, "expected chunk id '%s' or '%s', but got '%s'",
wire.StatusSyncData, wire.StatusSyncDone, []byte(status))
}
} | [
"func",
"readNextChunk",
"(",
"r",
"wire",
".",
"SyncScanner",
")",
"(",
"io",
".",
"Reader",
",",
"error",
")",
"{",
"status",
",",
"err",
":=",
"r",
".",
"ReadStatus",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"wire",
".",
"IsAdbServerErrorMatching",
"(",
"err",
",",
"readFileNotFoundPredicate",
")",
"{",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"errors",
".",
"FileNoExistError",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"switch",
"status",
"{",
"case",
"wire",
".",
"StatusSyncData",
":",
"return",
"r",
".",
"ReadBytes",
"(",
")",
"\n",
"case",
"wire",
".",
"StatusSyncDone",
":",
"return",
"nil",
",",
"io",
".",
"EOF",
"\n",
"default",
":",
"return",
"nil",
",",
"errors",
".",
"Errorf",
"(",
"errors",
".",
"AssertionError",
",",
"\"",
"\"",
",",
"wire",
".",
"StatusSyncData",
",",
"wire",
".",
"StatusSyncDone",
",",
"[",
"]",
"byte",
"(",
"status",
")",
")",
"\n",
"}",
"\n",
"}"
] | // readNextChunk creates an io.LimitedReader for the next chunk of data,
// and returns io.EOF if the last chunk has been read. | [
"readNextChunk",
"creates",
"an",
"io",
".",
"LimitedReader",
"for",
"the",
"next",
"chunk",
"of",
"data",
"and",
"returns",
"io",
".",
"EOF",
"if",
"the",
"last",
"chunk",
"has",
"been",
"read",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/sync_file_reader.go#L84-L102 |
13,634 | zach-klippenstein/goadb | cmd/adb/main.go | copyWithProgressAndStats | func copyWithProgressAndStats(dst io.Writer, src io.Reader, size int, showProgress bool) error {
var progress *pb.ProgressBar
if showProgress && size > 0 {
progress = pb.New(size)
// Write to stderr in case dst is stdout.
progress.Output = os.Stderr
progress.ShowSpeed = true
progress.ShowPercent = true
progress.ShowTimeLeft = true
progress.SetUnits(pb.U_BYTES)
progress.Start()
dst = io.MultiWriter(dst, progress)
}
startTime := time.Now()
copied, err := io.Copy(dst, src)
if progress != nil {
progress.Finish()
}
if pathErr, ok := err.(*os.PathError); ok {
if errno, ok := pathErr.Err.(syscall.Errno); ok && errno == syscall.EPIPE {
// Pipe closed. Handle this like an EOF.
err = nil
}
}
if err != nil {
return err
}
duration := time.Now().Sub(startTime)
rate := int64(float64(copied) / duration.Seconds())
fmt.Fprintf(os.Stderr, "%d B/s (%d bytes in %s)\n", rate, copied, duration)
return nil
} | go | func copyWithProgressAndStats(dst io.Writer, src io.Reader, size int, showProgress bool) error {
var progress *pb.ProgressBar
if showProgress && size > 0 {
progress = pb.New(size)
// Write to stderr in case dst is stdout.
progress.Output = os.Stderr
progress.ShowSpeed = true
progress.ShowPercent = true
progress.ShowTimeLeft = true
progress.SetUnits(pb.U_BYTES)
progress.Start()
dst = io.MultiWriter(dst, progress)
}
startTime := time.Now()
copied, err := io.Copy(dst, src)
if progress != nil {
progress.Finish()
}
if pathErr, ok := err.(*os.PathError); ok {
if errno, ok := pathErr.Err.(syscall.Errno); ok && errno == syscall.EPIPE {
// Pipe closed. Handle this like an EOF.
err = nil
}
}
if err != nil {
return err
}
duration := time.Now().Sub(startTime)
rate := int64(float64(copied) / duration.Seconds())
fmt.Fprintf(os.Stderr, "%d B/s (%d bytes in %s)\n", rate, copied, duration)
return nil
} | [
"func",
"copyWithProgressAndStats",
"(",
"dst",
"io",
".",
"Writer",
",",
"src",
"io",
".",
"Reader",
",",
"size",
"int",
",",
"showProgress",
"bool",
")",
"error",
"{",
"var",
"progress",
"*",
"pb",
".",
"ProgressBar",
"\n",
"if",
"showProgress",
"&&",
"size",
">",
"0",
"{",
"progress",
"=",
"pb",
".",
"New",
"(",
"size",
")",
"\n",
"// Write to stderr in case dst is stdout.",
"progress",
".",
"Output",
"=",
"os",
".",
"Stderr",
"\n",
"progress",
".",
"ShowSpeed",
"=",
"true",
"\n",
"progress",
".",
"ShowPercent",
"=",
"true",
"\n",
"progress",
".",
"ShowTimeLeft",
"=",
"true",
"\n",
"progress",
".",
"SetUnits",
"(",
"pb",
".",
"U_BYTES",
")",
"\n",
"progress",
".",
"Start",
"(",
")",
"\n",
"dst",
"=",
"io",
".",
"MultiWriter",
"(",
"dst",
",",
"progress",
")",
"\n",
"}",
"\n\n",
"startTime",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"copied",
",",
"err",
":=",
"io",
".",
"Copy",
"(",
"dst",
",",
"src",
")",
"\n\n",
"if",
"progress",
"!=",
"nil",
"{",
"progress",
".",
"Finish",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"pathErr",
",",
"ok",
":=",
"err",
".",
"(",
"*",
"os",
".",
"PathError",
")",
";",
"ok",
"{",
"if",
"errno",
",",
"ok",
":=",
"pathErr",
".",
"Err",
".",
"(",
"syscall",
".",
"Errno",
")",
";",
"ok",
"&&",
"errno",
"==",
"syscall",
".",
"EPIPE",
"{",
"// Pipe closed. Handle this like an EOF.",
"err",
"=",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"duration",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"startTime",
")",
"\n",
"rate",
":=",
"int64",
"(",
"float64",
"(",
"copied",
")",
"/",
"duration",
".",
"Seconds",
"(",
")",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"\"",
"\\n",
"\"",
",",
"rate",
",",
"copied",
",",
"duration",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // copyWithProgressAndStats copies src to dst.
// If showProgress is true and size is positive, a progress bar is shown.
// After copying, final stats about the transfer speed and size are shown.
// Progress and stats are printed to stderr. | [
"copyWithProgressAndStats",
"copies",
"src",
"to",
"dst",
".",
"If",
"showProgress",
"is",
"true",
"and",
"size",
"is",
"positive",
"a",
"progress",
"bar",
"is",
"shown",
".",
"After",
"copying",
"final",
"stats",
"about",
"the",
"transfer",
"speed",
"and",
"size",
"are",
"shown",
".",
"Progress",
"and",
"stats",
"are",
"printed",
"to",
"stderr",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/cmd/adb/main.go#L253-L289 |
13,635 | zach-klippenstein/goadb | device.go | OpenWrite | func (c *Device) OpenWrite(path string, perms os.FileMode, mtime time.Time) (io.WriteCloser, error) {
conn, err := c.getSyncConn()
if err != nil {
return nil, wrapClientError(err, c, "OpenWrite(%s)", path)
}
writer, err := sendFile(conn, path, perms, mtime)
return writer, wrapClientError(err, c, "OpenWrite(%s)", path)
} | go | func (c *Device) OpenWrite(path string, perms os.FileMode, mtime time.Time) (io.WriteCloser, error) {
conn, err := c.getSyncConn()
if err != nil {
return nil, wrapClientError(err, c, "OpenWrite(%s)", path)
}
writer, err := sendFile(conn, path, perms, mtime)
return writer, wrapClientError(err, c, "OpenWrite(%s)", path)
} | [
"func",
"(",
"c",
"*",
"Device",
")",
"OpenWrite",
"(",
"path",
"string",
",",
"perms",
"os",
".",
"FileMode",
",",
"mtime",
"time",
".",
"Time",
")",
"(",
"io",
".",
"WriteCloser",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"c",
".",
"getSyncConn",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"wrapClientError",
"(",
"err",
",",
"c",
",",
"\"",
"\"",
",",
"path",
")",
"\n",
"}",
"\n\n",
"writer",
",",
"err",
":=",
"sendFile",
"(",
"conn",
",",
"path",
",",
"perms",
",",
"mtime",
")",
"\n",
"return",
"writer",
",",
"wrapClientError",
"(",
"err",
",",
"c",
",",
"\"",
"\"",
",",
"path",
")",
"\n",
"}"
] | // OpenWrite opens the file at path on the device, creating it with the permissions specified
// by perms if necessary, and returns a writer that writes to the file.
// The files modification time will be set to mtime when the WriterCloser is closed. The zero value
// is TimeOfClose, which will use the time the Close method is called as the modification time. | [
"OpenWrite",
"opens",
"the",
"file",
"at",
"path",
"on",
"the",
"device",
"creating",
"it",
"with",
"the",
"permissions",
"specified",
"by",
"perms",
"if",
"necessary",
"and",
"returns",
"a",
"writer",
"that",
"writes",
"to",
"the",
"file",
".",
"The",
"files",
"modification",
"time",
"will",
"be",
"set",
"to",
"mtime",
"when",
"the",
"WriterCloser",
"is",
"closed",
".",
"The",
"zero",
"value",
"is",
"TimeOfClose",
"which",
"will",
"use",
"the",
"time",
"the",
"Close",
"method",
"is",
"called",
"as",
"the",
"modification",
"time",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device.go#L178-L186 |
13,636 | zach-klippenstein/goadb | device.go | dialDevice | func (c *Device) dialDevice() (*wire.Conn, error) {
conn, err := c.server.Dial()
if err != nil {
return nil, err
}
req := fmt.Sprintf("host:%s", c.descriptor.getTransportDescriptor())
if err = wire.SendMessageString(conn, req); err != nil {
conn.Close()
return nil, errors.WrapErrf(err, "error connecting to device '%s'", c.descriptor)
}
if _, err = conn.ReadStatus(req); err != nil {
conn.Close()
return nil, err
}
return conn, nil
} | go | func (c *Device) dialDevice() (*wire.Conn, error) {
conn, err := c.server.Dial()
if err != nil {
return nil, err
}
req := fmt.Sprintf("host:%s", c.descriptor.getTransportDescriptor())
if err = wire.SendMessageString(conn, req); err != nil {
conn.Close()
return nil, errors.WrapErrf(err, "error connecting to device '%s'", c.descriptor)
}
if _, err = conn.ReadStatus(req); err != nil {
conn.Close()
return nil, err
}
return conn, nil
} | [
"func",
"(",
"c",
"*",
"Device",
")",
"dialDevice",
"(",
")",
"(",
"*",
"wire",
".",
"Conn",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"c",
".",
"server",
".",
"Dial",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"req",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"c",
".",
"descriptor",
".",
"getTransportDescriptor",
"(",
")",
")",
"\n",
"if",
"err",
"=",
"wire",
".",
"SendMessageString",
"(",
"conn",
",",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"errors",
".",
"WrapErrf",
"(",
"err",
",",
"\"",
"\"",
",",
"c",
".",
"descriptor",
")",
"\n",
"}",
"\n\n",
"if",
"_",
",",
"err",
"=",
"conn",
".",
"ReadStatus",
"(",
"req",
")",
";",
"err",
"!=",
"nil",
"{",
"conn",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"conn",
",",
"nil",
"\n",
"}"
] | // dialDevice switches the connection to communicate directly with the device
// by requesting the transport defined by the DeviceDescriptor. | [
"dialDevice",
"switches",
"the",
"connection",
"to",
"communicate",
"directly",
"with",
"the",
"device",
"by",
"requesting",
"the",
"transport",
"defined",
"by",
"the",
"DeviceDescriptor",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device.go#L218-L236 |
13,637 | zach-klippenstein/goadb | device.go | prepareCommandLine | func prepareCommandLine(cmd string, args ...string) (string, error) {
if isBlank(cmd) {
return "", errors.AssertionErrorf("command cannot be empty")
}
for i, arg := range args {
if strings.ContainsRune(arg, '"') {
return "", errors.Errorf(errors.ParseError, "arg at index %d contains an invalid double quote: %s", i, arg)
}
if containsWhitespace(arg) {
args[i] = fmt.Sprintf("\"%s\"", arg)
}
}
// Prepend the command to the args array.
if len(args) > 0 {
cmd = fmt.Sprintf("%s %s", cmd, strings.Join(args, " "))
}
return cmd, nil
} | go | func prepareCommandLine(cmd string, args ...string) (string, error) {
if isBlank(cmd) {
return "", errors.AssertionErrorf("command cannot be empty")
}
for i, arg := range args {
if strings.ContainsRune(arg, '"') {
return "", errors.Errorf(errors.ParseError, "arg at index %d contains an invalid double quote: %s", i, arg)
}
if containsWhitespace(arg) {
args[i] = fmt.Sprintf("\"%s\"", arg)
}
}
// Prepend the command to the args array.
if len(args) > 0 {
cmd = fmt.Sprintf("%s %s", cmd, strings.Join(args, " "))
}
return cmd, nil
} | [
"func",
"prepareCommandLine",
"(",
"cmd",
"string",
",",
"args",
"...",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"isBlank",
"(",
"cmd",
")",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"AssertionErrorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"arg",
":=",
"range",
"args",
"{",
"if",
"strings",
".",
"ContainsRune",
"(",
"arg",
",",
"'\"'",
")",
"{",
"return",
"\"",
"\"",
",",
"errors",
".",
"Errorf",
"(",
"errors",
".",
"ParseError",
",",
"\"",
"\"",
",",
"i",
",",
"arg",
")",
"\n",
"}",
"\n",
"if",
"containsWhitespace",
"(",
"arg",
")",
"{",
"args",
"[",
"i",
"]",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"arg",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Prepend the command to the args array.",
"if",
"len",
"(",
"args",
")",
">",
"0",
"{",
"cmd",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"cmd",
",",
"strings",
".",
"Join",
"(",
"args",
",",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"return",
"cmd",
",",
"nil",
"\n",
"}"
] | // prepareCommandLine validates the command and argument strings, quotes
// arguments if required, and joins them into a valid adb command string. | [
"prepareCommandLine",
"validates",
"the",
"command",
"and",
"argument",
"strings",
"quotes",
"arguments",
"if",
"required",
"and",
"joins",
"them",
"into",
"a",
"valid",
"adb",
"command",
"string",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/device.go#L240-L260 |
13,638 | zach-klippenstein/goadb | sync_client.go | sendFile | func sendFile(conn *wire.SyncConn, path string, mode os.FileMode, mtime time.Time) (io.WriteCloser, error) {
if err := conn.SendOctetString("SEND"); err != nil {
return nil, err
}
pathAndMode := encodePathAndMode(path, mode)
if err := conn.SendBytes(pathAndMode); err != nil {
return nil, err
}
return newSyncFileWriter(conn, mtime), nil
} | go | func sendFile(conn *wire.SyncConn, path string, mode os.FileMode, mtime time.Time) (io.WriteCloser, error) {
if err := conn.SendOctetString("SEND"); err != nil {
return nil, err
}
pathAndMode := encodePathAndMode(path, mode)
if err := conn.SendBytes(pathAndMode); err != nil {
return nil, err
}
return newSyncFileWriter(conn, mtime), nil
} | [
"func",
"sendFile",
"(",
"conn",
"*",
"wire",
".",
"SyncConn",
",",
"path",
"string",
",",
"mode",
"os",
".",
"FileMode",
",",
"mtime",
"time",
".",
"Time",
")",
"(",
"io",
".",
"WriteCloser",
",",
"error",
")",
"{",
"if",
"err",
":=",
"conn",
".",
"SendOctetString",
"(",
"\"",
"\"",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"pathAndMode",
":=",
"encodePathAndMode",
"(",
"path",
",",
"mode",
")",
"\n",
"if",
"err",
":=",
"conn",
".",
"SendBytes",
"(",
"pathAndMode",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"newSyncFileWriter",
"(",
"conn",
",",
"mtime",
")",
",",
"nil",
"\n",
"}"
] | // sendFile returns a WriteCloser than will write to the file at path on device.
// The file will be created with permissions specified by mode.
// The file's modified time will be set to mtime, unless mtime is 0, in which case the time the writer is
// closed will be used. | [
"sendFile",
"returns",
"a",
"WriteCloser",
"than",
"will",
"write",
"to",
"the",
"file",
"at",
"path",
"on",
"device",
".",
"The",
"file",
"will",
"be",
"created",
"with",
"permissions",
"specified",
"by",
"mode",
".",
"The",
"file",
"s",
"modified",
"time",
"will",
"be",
"set",
"to",
"mtime",
"unless",
"mtime",
"is",
"0",
"in",
"which",
"case",
"the",
"time",
"the",
"writer",
"is",
"closed",
"will",
"be",
"used",
"."
] | 029cc6bee4812bf83c5d5fa58c49a82ff000d02c | https://github.com/zach-klippenstein/goadb/blob/029cc6bee4812bf83c5d5fa58c49a82ff000d02c/sync_client.go#L58-L69 |
13,639 | BurntSushi/graphics-go | graphics/detect/integral.go | newIntegrals | func newIntegrals(src image.Image) (*integral, *integral) {
b := src.Bounds()
srcg, ok := src.(*image.Gray)
if !ok {
srcg = image.NewGray(b)
draw.Draw(srcg, b, src, b.Min, draw.Src)
}
m := integral{
pix: make([]uint64, b.Max.Y*b.Max.X),
stride: b.Max.X,
rect: b,
}
mSq := integral{
pix: make([]uint64, b.Max.Y*b.Max.X),
stride: b.Max.X,
rect: b,
}
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
os := (y-b.Min.Y)*srcg.Stride + x - b.Min.X
om := (y-b.Min.Y)*m.stride + x - b.Min.X
c := uint64(srcg.Pix[os])
m.pix[om] = c
mSq.pix[om] = c * c
}
}
m.integrate()
mSq.integrate()
return &m, &mSq
} | go | func newIntegrals(src image.Image) (*integral, *integral) {
b := src.Bounds()
srcg, ok := src.(*image.Gray)
if !ok {
srcg = image.NewGray(b)
draw.Draw(srcg, b, src, b.Min, draw.Src)
}
m := integral{
pix: make([]uint64, b.Max.Y*b.Max.X),
stride: b.Max.X,
rect: b,
}
mSq := integral{
pix: make([]uint64, b.Max.Y*b.Max.X),
stride: b.Max.X,
rect: b,
}
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
os := (y-b.Min.Y)*srcg.Stride + x - b.Min.X
om := (y-b.Min.Y)*m.stride + x - b.Min.X
c := uint64(srcg.Pix[os])
m.pix[om] = c
mSq.pix[om] = c * c
}
}
m.integrate()
mSq.integrate()
return &m, &mSq
} | [
"func",
"newIntegrals",
"(",
"src",
"image",
".",
"Image",
")",
"(",
"*",
"integral",
",",
"*",
"integral",
")",
"{",
"b",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"srcg",
",",
"ok",
":=",
"src",
".",
"(",
"*",
"image",
".",
"Gray",
")",
"\n",
"if",
"!",
"ok",
"{",
"srcg",
"=",
"image",
".",
"NewGray",
"(",
"b",
")",
"\n",
"draw",
".",
"Draw",
"(",
"srcg",
",",
"b",
",",
"src",
",",
"b",
".",
"Min",
",",
"draw",
".",
"Src",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"integral",
"{",
"pix",
":",
"make",
"(",
"[",
"]",
"uint64",
",",
"b",
".",
"Max",
".",
"Y",
"*",
"b",
".",
"Max",
".",
"X",
")",
",",
"stride",
":",
"b",
".",
"Max",
".",
"X",
",",
"rect",
":",
"b",
",",
"}",
"\n",
"mSq",
":=",
"integral",
"{",
"pix",
":",
"make",
"(",
"[",
"]",
"uint64",
",",
"b",
".",
"Max",
".",
"Y",
"*",
"b",
".",
"Max",
".",
"X",
")",
",",
"stride",
":",
"b",
".",
"Max",
".",
"X",
",",
"rect",
":",
"b",
",",
"}",
"\n",
"for",
"y",
":=",
"b",
".",
"Min",
".",
"Y",
";",
"y",
"<",
"b",
".",
"Max",
".",
"Y",
";",
"y",
"++",
"{",
"for",
"x",
":=",
"b",
".",
"Min",
".",
"X",
";",
"x",
"<",
"b",
".",
"Max",
".",
"X",
";",
"x",
"++",
"{",
"os",
":=",
"(",
"y",
"-",
"b",
".",
"Min",
".",
"Y",
")",
"*",
"srcg",
".",
"Stride",
"+",
"x",
"-",
"b",
".",
"Min",
".",
"X",
"\n",
"om",
":=",
"(",
"y",
"-",
"b",
".",
"Min",
".",
"Y",
")",
"*",
"m",
".",
"stride",
"+",
"x",
"-",
"b",
".",
"Min",
".",
"X",
"\n",
"c",
":=",
"uint64",
"(",
"srcg",
".",
"Pix",
"[",
"os",
"]",
")",
"\n",
"m",
".",
"pix",
"[",
"om",
"]",
"=",
"c",
"\n",
"mSq",
".",
"pix",
"[",
"om",
"]",
"=",
"c",
"*",
"c",
"\n",
"}",
"\n",
"}",
"\n",
"m",
".",
"integrate",
"(",
")",
"\n",
"mSq",
".",
"integrate",
"(",
")",
"\n",
"return",
"&",
"m",
",",
"&",
"mSq",
"\n",
"}"
] | // newIntegrals returns the integral and the squared integral. | [
"newIntegrals",
"returns",
"the",
"integral",
"and",
"the",
"squared",
"integral",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/integral.go#L63-L93 |
13,640 | BurntSushi/graphics-go | graphics/rotate.go | Rotate | func Rotate(dst draw.Image, src image.Image, opt *RotateOptions) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
angle := 0.0
if opt != nil {
angle = opt.Angle
}
return I.Rotate(angle).TransformCenter(dst, src, interp.Bilinear)
} | go | func Rotate(dst draw.Image, src image.Image, opt *RotateOptions) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
angle := 0.0
if opt != nil {
angle = opt.Angle
}
return I.Rotate(angle).TransformCenter(dst, src, interp.Bilinear)
} | [
"func",
"Rotate",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"opt",
"*",
"RotateOptions",
")",
"error",
"{",
"if",
"dst",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"src",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"angle",
":=",
"0.0",
"\n",
"if",
"opt",
"!=",
"nil",
"{",
"angle",
"=",
"opt",
".",
"Angle",
"\n",
"}",
"\n\n",
"return",
"I",
".",
"Rotate",
"(",
"angle",
")",
".",
"TransformCenter",
"(",
"dst",
",",
"src",
",",
"interp",
".",
"Bilinear",
")",
"\n",
"}"
] | // Rotate produces a rotated version of src, drawn onto dst. | [
"Rotate",
"produces",
"a",
"rotated",
"version",
"of",
"src",
"drawn",
"onto",
"dst",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/rotate.go#L21-L35 |
13,641 | BurntSushi/graphics-go | graphics/affine.go | Mul | func (a Affine) Mul(b Affine) Affine {
return Affine{
a[0]*b[0] + a[1]*b[3] + a[2]*b[6],
a[0]*b[1] + a[1]*b[4] + a[2]*b[7],
a[0]*b[2] + a[1]*b[5] + a[2]*b[8],
a[3]*b[0] + a[4]*b[3] + a[5]*b[6],
a[3]*b[1] + a[4]*b[4] + a[5]*b[7],
a[3]*b[2] + a[4]*b[5] + a[5]*b[8],
a[6]*b[0] + a[7]*b[3] + a[8]*b[6],
a[6]*b[1] + a[7]*b[4] + a[8]*b[7],
a[6]*b[2] + a[7]*b[5] + a[8]*b[8],
}
} | go | func (a Affine) Mul(b Affine) Affine {
return Affine{
a[0]*b[0] + a[1]*b[3] + a[2]*b[6],
a[0]*b[1] + a[1]*b[4] + a[2]*b[7],
a[0]*b[2] + a[1]*b[5] + a[2]*b[8],
a[3]*b[0] + a[4]*b[3] + a[5]*b[6],
a[3]*b[1] + a[4]*b[4] + a[5]*b[7],
a[3]*b[2] + a[4]*b[5] + a[5]*b[8],
a[6]*b[0] + a[7]*b[3] + a[8]*b[6],
a[6]*b[1] + a[7]*b[4] + a[8]*b[7],
a[6]*b[2] + a[7]*b[5] + a[8]*b[8],
}
} | [
"func",
"(",
"a",
"Affine",
")",
"Mul",
"(",
"b",
"Affine",
")",
"Affine",
"{",
"return",
"Affine",
"{",
"a",
"[",
"0",
"]",
"*",
"b",
"[",
"0",
"]",
"+",
"a",
"[",
"1",
"]",
"*",
"b",
"[",
"3",
"]",
"+",
"a",
"[",
"2",
"]",
"*",
"b",
"[",
"6",
"]",
",",
"a",
"[",
"0",
"]",
"*",
"b",
"[",
"1",
"]",
"+",
"a",
"[",
"1",
"]",
"*",
"b",
"[",
"4",
"]",
"+",
"a",
"[",
"2",
"]",
"*",
"b",
"[",
"7",
"]",
",",
"a",
"[",
"0",
"]",
"*",
"b",
"[",
"2",
"]",
"+",
"a",
"[",
"1",
"]",
"*",
"b",
"[",
"5",
"]",
"+",
"a",
"[",
"2",
"]",
"*",
"b",
"[",
"8",
"]",
",",
"a",
"[",
"3",
"]",
"*",
"b",
"[",
"0",
"]",
"+",
"a",
"[",
"4",
"]",
"*",
"b",
"[",
"3",
"]",
"+",
"a",
"[",
"5",
"]",
"*",
"b",
"[",
"6",
"]",
",",
"a",
"[",
"3",
"]",
"*",
"b",
"[",
"1",
"]",
"+",
"a",
"[",
"4",
"]",
"*",
"b",
"[",
"4",
"]",
"+",
"a",
"[",
"5",
"]",
"*",
"b",
"[",
"7",
"]",
",",
"a",
"[",
"3",
"]",
"*",
"b",
"[",
"2",
"]",
"+",
"a",
"[",
"4",
"]",
"*",
"b",
"[",
"5",
"]",
"+",
"a",
"[",
"5",
"]",
"*",
"b",
"[",
"8",
"]",
",",
"a",
"[",
"6",
"]",
"*",
"b",
"[",
"0",
"]",
"+",
"a",
"[",
"7",
"]",
"*",
"b",
"[",
"3",
"]",
"+",
"a",
"[",
"8",
"]",
"*",
"b",
"[",
"6",
"]",
",",
"a",
"[",
"6",
"]",
"*",
"b",
"[",
"1",
"]",
"+",
"a",
"[",
"7",
"]",
"*",
"b",
"[",
"4",
"]",
"+",
"a",
"[",
"8",
"]",
"*",
"b",
"[",
"7",
"]",
",",
"a",
"[",
"6",
"]",
"*",
"b",
"[",
"2",
"]",
"+",
"a",
"[",
"7",
"]",
"*",
"b",
"[",
"5",
"]",
"+",
"a",
"[",
"8",
"]",
"*",
"b",
"[",
"8",
"]",
",",
"}",
"\n",
"}"
] | // Mul returns the multiplication of two affine transform matrices. | [
"Mul",
"returns",
"the",
"multiplication",
"of",
"two",
"affine",
"transform",
"matrices",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L27-L39 |
13,642 | BurntSushi/graphics-go | graphics/affine.go | Transform | func (a Affine) Transform(dst draw.Image, src image.Image, i interp.Interp) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
// RGBA fast path.
dstRGBA, dstOk := dst.(*image.RGBA)
srcRGBA, srcOk := src.(*image.RGBA)
interpRGBA, interpOk := i.(interp.RGBA)
if dstOk && srcOk && interpOk {
return a.transformRGBA(dstRGBA, srcRGBA, interpRGBA)
}
srcb := src.Bounds()
b := dst.Bounds()
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
sx, sy := a.pt(x, y)
if inBounds(srcb, sx, sy) {
dst.Set(x, y, i.Interp(src, sx, sy))
}
}
}
return nil
} | go | func (a Affine) Transform(dst draw.Image, src image.Image, i interp.Interp) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
// RGBA fast path.
dstRGBA, dstOk := dst.(*image.RGBA)
srcRGBA, srcOk := src.(*image.RGBA)
interpRGBA, interpOk := i.(interp.RGBA)
if dstOk && srcOk && interpOk {
return a.transformRGBA(dstRGBA, srcRGBA, interpRGBA)
}
srcb := src.Bounds()
b := dst.Bounds()
for y := b.Min.Y; y < b.Max.Y; y++ {
for x := b.Min.X; x < b.Max.X; x++ {
sx, sy := a.pt(x, y)
if inBounds(srcb, sx, sy) {
dst.Set(x, y, i.Interp(src, sx, sy))
}
}
}
return nil
} | [
"func",
"(",
"a",
"Affine",
")",
"Transform",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"i",
"interp",
".",
"Interp",
")",
"error",
"{",
"if",
"dst",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"src",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// RGBA fast path.",
"dstRGBA",
",",
"dstOk",
":=",
"dst",
".",
"(",
"*",
"image",
".",
"RGBA",
")",
"\n",
"srcRGBA",
",",
"srcOk",
":=",
"src",
".",
"(",
"*",
"image",
".",
"RGBA",
")",
"\n",
"interpRGBA",
",",
"interpOk",
":=",
"i",
".",
"(",
"interp",
".",
"RGBA",
")",
"\n",
"if",
"dstOk",
"&&",
"srcOk",
"&&",
"interpOk",
"{",
"return",
"a",
".",
"transformRGBA",
"(",
"dstRGBA",
",",
"srcRGBA",
",",
"interpRGBA",
")",
"\n",
"}",
"\n\n",
"srcb",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"b",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"for",
"y",
":=",
"b",
".",
"Min",
".",
"Y",
";",
"y",
"<",
"b",
".",
"Max",
".",
"Y",
";",
"y",
"++",
"{",
"for",
"x",
":=",
"b",
".",
"Min",
".",
"X",
";",
"x",
"<",
"b",
".",
"Max",
".",
"X",
";",
"x",
"++",
"{",
"sx",
",",
"sy",
":=",
"a",
".",
"pt",
"(",
"x",
",",
"y",
")",
"\n",
"if",
"inBounds",
"(",
"srcb",
",",
"sx",
",",
"sy",
")",
"{",
"dst",
".",
"Set",
"(",
"x",
",",
"y",
",",
"i",
".",
"Interp",
"(",
"src",
",",
"sx",
",",
"sy",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Transform applies the affine transform to src and produces dst. | [
"Transform",
"applies",
"the",
"affine",
"transform",
"to",
"src",
"and",
"produces",
"dst",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L61-L88 |
13,643 | BurntSushi/graphics-go | graphics/affine.go | Scale | func (a Affine) Scale(x, y float64) Affine {
return a.Mul(Affine{
1 / x, 0, 0,
0, 1 / y, 0,
0, 0, 1,
})
} | go | func (a Affine) Scale(x, y float64) Affine {
return a.Mul(Affine{
1 / x, 0, 0,
0, 1 / y, 0,
0, 0, 1,
})
} | [
"func",
"(",
"a",
"Affine",
")",
"Scale",
"(",
"x",
",",
"y",
"float64",
")",
"Affine",
"{",
"return",
"a",
".",
"Mul",
"(",
"Affine",
"{",
"1",
"/",
"x",
",",
"0",
",",
"0",
",",
"0",
",",
"1",
"/",
"y",
",",
"0",
",",
"0",
",",
"0",
",",
"1",
",",
"}",
")",
"\n",
"}"
] | // Scale produces a scaling transform of factors x and y. | [
"Scale",
"produces",
"a",
"scaling",
"transform",
"of",
"factors",
"x",
"and",
"y",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L123-L129 |
13,644 | BurntSushi/graphics-go | graphics/affine.go | Rotate | func (a Affine) Rotate(angle float64) Affine {
s, c := math.Sincos(angle)
return a.Mul(Affine{
+c, +s, +0,
-s, +c, +0,
+0, +0, +1,
})
} | go | func (a Affine) Rotate(angle float64) Affine {
s, c := math.Sincos(angle)
return a.Mul(Affine{
+c, +s, +0,
-s, +c, +0,
+0, +0, +1,
})
} | [
"func",
"(",
"a",
"Affine",
")",
"Rotate",
"(",
"angle",
"float64",
")",
"Affine",
"{",
"s",
",",
"c",
":=",
"math",
".",
"Sincos",
"(",
"angle",
")",
"\n",
"return",
"a",
".",
"Mul",
"(",
"Affine",
"{",
"+",
"c",
",",
"+",
"s",
",",
"+",
"0",
",",
"-",
"s",
",",
"+",
"c",
",",
"+",
"0",
",",
"+",
"0",
",",
"+",
"0",
",",
"+",
"1",
",",
"}",
")",
"\n",
"}"
] | // Rotate produces a clockwise rotation transform of angle, in radians. | [
"Rotate",
"produces",
"a",
"clockwise",
"rotation",
"transform",
"of",
"angle",
"in",
"radians",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L132-L139 |
13,645 | BurntSushi/graphics-go | graphics/affine.go | Shear | func (a Affine) Shear(x, y float64) Affine {
d := 1 - x*y
return a.Mul(Affine{
+1 / d, -x / d, 0,
-y / d, +1 / d, 0,
0, 0, 1,
})
} | go | func (a Affine) Shear(x, y float64) Affine {
d := 1 - x*y
return a.Mul(Affine{
+1 / d, -x / d, 0,
-y / d, +1 / d, 0,
0, 0, 1,
})
} | [
"func",
"(",
"a",
"Affine",
")",
"Shear",
"(",
"x",
",",
"y",
"float64",
")",
"Affine",
"{",
"d",
":=",
"1",
"-",
"x",
"*",
"y",
"\n",
"return",
"a",
".",
"Mul",
"(",
"Affine",
"{",
"+",
"1",
"/",
"d",
",",
"-",
"x",
"/",
"d",
",",
"0",
",",
"-",
"y",
"/",
"d",
",",
"+",
"1",
"/",
"d",
",",
"0",
",",
"0",
",",
"0",
",",
"1",
",",
"}",
")",
"\n",
"}"
] | // Shear produces a shear transform by the slopes x and y. | [
"Shear",
"produces",
"a",
"shear",
"transform",
"by",
"the",
"slopes",
"x",
"and",
"y",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L142-L149 |
13,646 | BurntSushi/graphics-go | graphics/affine.go | Translate | func (a Affine) Translate(x, y float64) Affine {
return a.Mul(Affine{
1, 0, -x,
0, 1, -y,
0, 0, +1,
})
} | go | func (a Affine) Translate(x, y float64) Affine {
return a.Mul(Affine{
1, 0, -x,
0, 1, -y,
0, 0, +1,
})
} | [
"func",
"(",
"a",
"Affine",
")",
"Translate",
"(",
"x",
",",
"y",
"float64",
")",
"Affine",
"{",
"return",
"a",
".",
"Mul",
"(",
"Affine",
"{",
"1",
",",
"0",
",",
"-",
"x",
",",
"0",
",",
"1",
",",
"-",
"y",
",",
"0",
",",
"0",
",",
"+",
"1",
",",
"}",
")",
"\n",
"}"
] | // Translate produces a translation transform with pixel distances x and y. | [
"Translate",
"produces",
"a",
"translation",
"transform",
"with",
"pixel",
"distances",
"x",
"and",
"y",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L152-L158 |
13,647 | BurntSushi/graphics-go | graphics/affine.go | Center | func (a Affine) Center(x, y float64) Affine {
return I.Translate(-x, -y).Mul(a).Translate(x, y)
} | go | func (a Affine) Center(x, y float64) Affine {
return I.Translate(-x, -y).Mul(a).Translate(x, y)
} | [
"func",
"(",
"a",
"Affine",
")",
"Center",
"(",
"x",
",",
"y",
"float64",
")",
"Affine",
"{",
"return",
"I",
".",
"Translate",
"(",
"-",
"x",
",",
"-",
"y",
")",
".",
"Mul",
"(",
"a",
")",
".",
"Translate",
"(",
"x",
",",
"y",
")",
"\n",
"}"
] | // Center produces the affine transform, centered around the provided point. | [
"Center",
"produces",
"the",
"affine",
"transform",
"centered",
"around",
"the",
"provided",
"point",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/affine.go#L161-L163 |
13,648 | BurntSushi/graphics-go | graphics/convolve/convolve.go | NewKernel | func NewKernel(w []float64) (Kernel, error) {
if _, err := kernelSize(w); err != nil {
return nil, err
}
return fullKernel(w), nil
} | go | func NewKernel(w []float64) (Kernel, error) {
if _, err := kernelSize(w); err != nil {
return nil, err
}
return fullKernel(w), nil
} | [
"func",
"NewKernel",
"(",
"w",
"[",
"]",
"float64",
")",
"(",
"Kernel",
",",
"error",
")",
"{",
"if",
"_",
",",
"err",
":=",
"kernelSize",
"(",
"w",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"fullKernel",
"(",
"w",
")",
",",
"nil",
"\n",
"}"
] | // NewKernel returns a square convolution kernel. | [
"NewKernel",
"returns",
"a",
"square",
"convolution",
"kernel",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/convolve/convolve.go#L72-L77 |
13,649 | BurntSushi/graphics-go | graphics/convolve/convolve.go | Convolve | func Convolve(dst draw.Image, src image.Image, k Kernel) (err error) {
if dst == nil || src == nil || k == nil {
return nil
}
b := dst.Bounds()
dstRgba, ok := dst.(*image.RGBA)
if !ok {
dstRgba = image.NewRGBA(b)
}
switch k := k.(type) {
case *SeparableKernel:
err = convolveRGBASep(dstRgba, src, k)
default:
err = convolveRGBA(dstRgba, src, k)
}
if err != nil {
return err
}
if !ok {
draw.Draw(dst, b, dstRgba, b.Min, draw.Src)
}
return nil
} | go | func Convolve(dst draw.Image, src image.Image, k Kernel) (err error) {
if dst == nil || src == nil || k == nil {
return nil
}
b := dst.Bounds()
dstRgba, ok := dst.(*image.RGBA)
if !ok {
dstRgba = image.NewRGBA(b)
}
switch k := k.(type) {
case *SeparableKernel:
err = convolveRGBASep(dstRgba, src, k)
default:
err = convolveRGBA(dstRgba, src, k)
}
if err != nil {
return err
}
if !ok {
draw.Draw(dst, b, dstRgba, b.Min, draw.Src)
}
return nil
} | [
"func",
"Convolve",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"k",
"Kernel",
")",
"(",
"err",
"error",
")",
"{",
"if",
"dst",
"==",
"nil",
"||",
"src",
"==",
"nil",
"||",
"k",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"b",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"dstRgba",
",",
"ok",
":=",
"dst",
".",
"(",
"*",
"image",
".",
"RGBA",
")",
"\n",
"if",
"!",
"ok",
"{",
"dstRgba",
"=",
"image",
".",
"NewRGBA",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"switch",
"k",
":=",
"k",
".",
"(",
"type",
")",
"{",
"case",
"*",
"SeparableKernel",
":",
"err",
"=",
"convolveRGBASep",
"(",
"dstRgba",
",",
"src",
",",
"k",
")",
"\n",
"default",
":",
"err",
"=",
"convolveRGBA",
"(",
"dstRgba",
",",
"src",
",",
"k",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"ok",
"{",
"draw",
".",
"Draw",
"(",
"dst",
",",
"b",
",",
"dstRgba",
",",
"b",
".",
"Min",
",",
"draw",
".",
"Src",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // Convolve produces dst by applying the convolution kernel k to src. | [
"Convolve",
"produces",
"dst",
"by",
"applying",
"the",
"convolution",
"kernel",
"k",
"to",
"src",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/convolve/convolve.go#L248-L274 |
13,650 | BurntSushi/graphics-go | graphics/scale.go | Scale | func Scale(dst draw.Image, src image.Image) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
b := dst.Bounds()
srcb := src.Bounds()
if b.Empty() || srcb.Empty() {
return nil
}
sx := float64(b.Dx()) / float64(srcb.Dx())
sy := float64(b.Dy()) / float64(srcb.Dy())
return I.Scale(sx, sy).Transform(dst, src, interp.Bilinear)
} | go | func Scale(dst draw.Image, src image.Image) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
b := dst.Bounds()
srcb := src.Bounds()
if b.Empty() || srcb.Empty() {
return nil
}
sx := float64(b.Dx()) / float64(srcb.Dx())
sy := float64(b.Dy()) / float64(srcb.Dy())
return I.Scale(sx, sy).Transform(dst, src, interp.Bilinear)
} | [
"func",
"Scale",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
")",
"error",
"{",
"if",
"dst",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"src",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"b",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"srcb",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"if",
"b",
".",
"Empty",
"(",
")",
"||",
"srcb",
".",
"Empty",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"sx",
":=",
"float64",
"(",
"b",
".",
"Dx",
"(",
")",
")",
"/",
"float64",
"(",
"srcb",
".",
"Dx",
"(",
")",
")",
"\n",
"sy",
":=",
"float64",
"(",
"b",
".",
"Dy",
"(",
")",
")",
"/",
"float64",
"(",
"srcb",
".",
"Dy",
"(",
")",
")",
"\n",
"return",
"I",
".",
"Scale",
"(",
"sx",
",",
"sy",
")",
".",
"Transform",
"(",
"dst",
",",
"src",
",",
"interp",
".",
"Bilinear",
")",
"\n",
"}"
] | // Scale produces a scaled version of the image using bilinear interpolation. | [
"Scale",
"produces",
"a",
"scaled",
"version",
"of",
"the",
"image",
"using",
"bilinear",
"interpolation",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/scale.go#L15-L31 |
13,651 | BurntSushi/graphics-go | graphics/detect/detect.go | Match | func (c *Cascade) Match(m image.Image) bool {
return c.classify(newWindow(m))
} | go | func (c *Cascade) Match(m image.Image) bool {
return c.classify(newWindow(m))
} | [
"func",
"(",
"c",
"*",
"Cascade",
")",
"Match",
"(",
"m",
"image",
".",
"Image",
")",
"bool",
"{",
"return",
"c",
".",
"classify",
"(",
"newWindow",
"(",
"m",
")",
")",
"\n",
"}"
] | // Match returns true if the full image is classified as an object. | [
"Match",
"returns",
"true",
"if",
"the",
"full",
"image",
"is",
"classified",
"as",
"an",
"object",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/detect.go#L39-L41 |
13,652 | BurntSushi/graphics-go | graphics/detect/detect.go | Find | func (c *Cascade) Find(m image.Image) []image.Rectangle {
// TODO(crawshaw): Consider de-duping strategies.
matches := []image.Rectangle{}
w := newWindow(m)
b := m.Bounds()
origScale := c.Size
for s := origScale; s.X < b.Dx() && s.Y < b.Dy(); s = s.Add(s.Div(10)) {
// translate region and classify
tx := image.Pt(s.X/10, 0)
ty := image.Pt(0, s.Y/10)
for r := image.Rect(0, 0, s.X, s.Y).Add(b.Min); r.In(b); r = r.Add(ty) {
for r1 := r; r1.In(b); r1 = r1.Add(tx) {
if c.classify(w.subWindow(r1)) {
matches = append(matches, r1)
}
}
}
}
return matches
} | go | func (c *Cascade) Find(m image.Image) []image.Rectangle {
// TODO(crawshaw): Consider de-duping strategies.
matches := []image.Rectangle{}
w := newWindow(m)
b := m.Bounds()
origScale := c.Size
for s := origScale; s.X < b.Dx() && s.Y < b.Dy(); s = s.Add(s.Div(10)) {
// translate region and classify
tx := image.Pt(s.X/10, 0)
ty := image.Pt(0, s.Y/10)
for r := image.Rect(0, 0, s.X, s.Y).Add(b.Min); r.In(b); r = r.Add(ty) {
for r1 := r; r1.In(b); r1 = r1.Add(tx) {
if c.classify(w.subWindow(r1)) {
matches = append(matches, r1)
}
}
}
}
return matches
} | [
"func",
"(",
"c",
"*",
"Cascade",
")",
"Find",
"(",
"m",
"image",
".",
"Image",
")",
"[",
"]",
"image",
".",
"Rectangle",
"{",
"// TODO(crawshaw): Consider de-duping strategies.",
"matches",
":=",
"[",
"]",
"image",
".",
"Rectangle",
"{",
"}",
"\n",
"w",
":=",
"newWindow",
"(",
"m",
")",
"\n\n",
"b",
":=",
"m",
".",
"Bounds",
"(",
")",
"\n",
"origScale",
":=",
"c",
".",
"Size",
"\n",
"for",
"s",
":=",
"origScale",
";",
"s",
".",
"X",
"<",
"b",
".",
"Dx",
"(",
")",
"&&",
"s",
".",
"Y",
"<",
"b",
".",
"Dy",
"(",
")",
";",
"s",
"=",
"s",
".",
"Add",
"(",
"s",
".",
"Div",
"(",
"10",
")",
")",
"{",
"// translate region and classify",
"tx",
":=",
"image",
".",
"Pt",
"(",
"s",
".",
"X",
"/",
"10",
",",
"0",
")",
"\n",
"ty",
":=",
"image",
".",
"Pt",
"(",
"0",
",",
"s",
".",
"Y",
"/",
"10",
")",
"\n",
"for",
"r",
":=",
"image",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"s",
".",
"X",
",",
"s",
".",
"Y",
")",
".",
"Add",
"(",
"b",
".",
"Min",
")",
";",
"r",
".",
"In",
"(",
"b",
")",
";",
"r",
"=",
"r",
".",
"Add",
"(",
"ty",
")",
"{",
"for",
"r1",
":=",
"r",
";",
"r1",
".",
"In",
"(",
"b",
")",
";",
"r1",
"=",
"r1",
".",
"Add",
"(",
"tx",
")",
"{",
"if",
"c",
".",
"classify",
"(",
"w",
".",
"subWindow",
"(",
"r1",
")",
")",
"{",
"matches",
"=",
"append",
"(",
"matches",
",",
"r1",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"matches",
"\n",
"}"
] | // Find returns a set of areas of m that match the feature cascade c. | [
"Find",
"returns",
"a",
"set",
"of",
"areas",
"of",
"m",
"that",
"match",
"the",
"feature",
"cascade",
"c",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/detect.go#L44-L64 |
13,653 | BurntSushi/graphics-go | graphics/detect/opencv_parser.go | ParseOpenCV | func ParseOpenCV(r io.Reader) (cascade *Cascade, name string, err error) {
// BUG(crawshaw): tag-based parsing doesn't seem to work with <_>
buf, err := ioutil.ReadAll(r)
if err != nil {
return
}
buf = bytes.Replace(buf, []byte("<_>"), []byte("<grp>"), -1)
buf = bytes.Replace(buf, []byte("</_>"), []byte("</grp>"), -1)
s := &opencv_storage{}
err = xml.Unmarshal(buf, s)
if err != nil {
return
}
return buildCascade(s)
} | go | func ParseOpenCV(r io.Reader) (cascade *Cascade, name string, err error) {
// BUG(crawshaw): tag-based parsing doesn't seem to work with <_>
buf, err := ioutil.ReadAll(r)
if err != nil {
return
}
buf = bytes.Replace(buf, []byte("<_>"), []byte("<grp>"), -1)
buf = bytes.Replace(buf, []byte("</_>"), []byte("</grp>"), -1)
s := &opencv_storage{}
err = xml.Unmarshal(buf, s)
if err != nil {
return
}
return buildCascade(s)
} | [
"func",
"ParseOpenCV",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"cascade",
"*",
"Cascade",
",",
"name",
"string",
",",
"err",
"error",
")",
"{",
"// BUG(crawshaw): tag-based parsing doesn't seem to work with <_>",
"buf",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"buf",
"=",
"bytes",
".",
"Replace",
"(",
"buf",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"-",
"1",
")",
"\n",
"buf",
"=",
"bytes",
".",
"Replace",
"(",
"buf",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"[",
"]",
"byte",
"(",
"\"",
"\"",
")",
",",
"-",
"1",
")",
"\n\n",
"s",
":=",
"&",
"opencv_storage",
"{",
"}",
"\n",
"err",
"=",
"xml",
".",
"Unmarshal",
"(",
"buf",
",",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"return",
"buildCascade",
"(",
"s",
")",
"\n",
"}"
] | // ParseOpenCV produces a detection Cascade from an OpenCV XML file. | [
"ParseOpenCV",
"produces",
"a",
"detection",
"Cascade",
"from",
"an",
"OpenCV",
"XML",
"file",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/opencv_parser.go#L110-L125 |
13,654 | BurntSushi/graphics-go | graphics/blur.go | Blur | func Blur(dst draw.Image, src image.Image, opt *BlurOptions) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
sd := DefaultStdDev
size := 0
if opt != nil {
sd = opt.StdDev
size = opt.Size
}
if size < 1 {
size = int(math.Ceil(sd * 6))
}
kernel := make([]float64, 2*size+1)
for i := 0; i <= size; i++ {
x := float64(i) / sd
x = math.Pow(1/math.SqrtE, x*x)
kernel[size-i] = x
kernel[size+i] = x
}
// Normalize the weights to sum to 1.0.
kSum := 0.0
for _, k := range kernel {
kSum += k
}
for i, k := range kernel {
kernel[i] = k / kSum
}
return convolve.Convolve(dst, src, &convolve.SeparableKernel{
X: kernel,
Y: kernel,
})
} | go | func Blur(dst draw.Image, src image.Image, opt *BlurOptions) error {
if dst == nil {
return errors.New("graphics: dst is nil")
}
if src == nil {
return errors.New("graphics: src is nil")
}
sd := DefaultStdDev
size := 0
if opt != nil {
sd = opt.StdDev
size = opt.Size
}
if size < 1 {
size = int(math.Ceil(sd * 6))
}
kernel := make([]float64, 2*size+1)
for i := 0; i <= size; i++ {
x := float64(i) / sd
x = math.Pow(1/math.SqrtE, x*x)
kernel[size-i] = x
kernel[size+i] = x
}
// Normalize the weights to sum to 1.0.
kSum := 0.0
for _, k := range kernel {
kSum += k
}
for i, k := range kernel {
kernel[i] = k / kSum
}
return convolve.Convolve(dst, src, &convolve.SeparableKernel{
X: kernel,
Y: kernel,
})
} | [
"func",
"Blur",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
",",
"opt",
"*",
"BlurOptions",
")",
"error",
"{",
"if",
"dst",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"src",
"==",
"nil",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sd",
":=",
"DefaultStdDev",
"\n",
"size",
":=",
"0",
"\n\n",
"if",
"opt",
"!=",
"nil",
"{",
"sd",
"=",
"opt",
".",
"StdDev",
"\n",
"size",
"=",
"opt",
".",
"Size",
"\n",
"}",
"\n\n",
"if",
"size",
"<",
"1",
"{",
"size",
"=",
"int",
"(",
"math",
".",
"Ceil",
"(",
"sd",
"*",
"6",
")",
")",
"\n",
"}",
"\n\n",
"kernel",
":=",
"make",
"(",
"[",
"]",
"float64",
",",
"2",
"*",
"size",
"+",
"1",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<=",
"size",
";",
"i",
"++",
"{",
"x",
":=",
"float64",
"(",
"i",
")",
"/",
"sd",
"\n",
"x",
"=",
"math",
".",
"Pow",
"(",
"1",
"/",
"math",
".",
"SqrtE",
",",
"x",
"*",
"x",
")",
"\n",
"kernel",
"[",
"size",
"-",
"i",
"]",
"=",
"x",
"\n",
"kernel",
"[",
"size",
"+",
"i",
"]",
"=",
"x",
"\n",
"}",
"\n\n",
"// Normalize the weights to sum to 1.0.",
"kSum",
":=",
"0.0",
"\n",
"for",
"_",
",",
"k",
":=",
"range",
"kernel",
"{",
"kSum",
"+=",
"k",
"\n",
"}",
"\n",
"for",
"i",
",",
"k",
":=",
"range",
"kernel",
"{",
"kernel",
"[",
"i",
"]",
"=",
"k",
"/",
"kSum",
"\n",
"}",
"\n\n",
"return",
"convolve",
".",
"Convolve",
"(",
"dst",
",",
"src",
",",
"&",
"convolve",
".",
"SeparableKernel",
"{",
"X",
":",
"kernel",
",",
"Y",
":",
"kernel",
",",
"}",
")",
"\n",
"}"
] | // Blur produces a blurred version of the image, using a Gaussian blur. | [
"Blur",
"produces",
"a",
"blurred",
"version",
"of",
"the",
"image",
"using",
"a",
"Gaussian",
"blur",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/blur.go#L27-L68 |
13,655 | BurntSushi/graphics-go | graphics/thumbnail.go | Thumbnail | func Thumbnail(dst draw.Image, src image.Image) error {
// Scale down src in the dimension that is closer to dst.
sb := src.Bounds()
db := dst.Bounds()
rx := float64(sb.Dx()) / float64(db.Dx())
ry := float64(sb.Dy()) / float64(db.Dy())
var b image.Rectangle
if rx < ry {
b = image.Rect(0, 0, db.Dx(), int(float64(sb.Dy())/rx))
} else {
b = image.Rect(0, 0, int(float64(sb.Dx())/ry), db.Dy())
}
buf := image.NewRGBA(b)
if err := Scale(buf, src); err != nil {
return err
}
// Crop.
// TODO(crawshaw): improve on center-alignment.
var pt image.Point
if rx < ry {
pt.Y = (b.Dy() - db.Dy()) / 2
} else {
pt.X = (b.Dx() - db.Dx()) / 2
}
draw.Draw(dst, db, buf, pt, draw.Src)
return nil
} | go | func Thumbnail(dst draw.Image, src image.Image) error {
// Scale down src in the dimension that is closer to dst.
sb := src.Bounds()
db := dst.Bounds()
rx := float64(sb.Dx()) / float64(db.Dx())
ry := float64(sb.Dy()) / float64(db.Dy())
var b image.Rectangle
if rx < ry {
b = image.Rect(0, 0, db.Dx(), int(float64(sb.Dy())/rx))
} else {
b = image.Rect(0, 0, int(float64(sb.Dx())/ry), db.Dy())
}
buf := image.NewRGBA(b)
if err := Scale(buf, src); err != nil {
return err
}
// Crop.
// TODO(crawshaw): improve on center-alignment.
var pt image.Point
if rx < ry {
pt.Y = (b.Dy() - db.Dy()) / 2
} else {
pt.X = (b.Dx() - db.Dx()) / 2
}
draw.Draw(dst, db, buf, pt, draw.Src)
return nil
} | [
"func",
"Thumbnail",
"(",
"dst",
"draw",
".",
"Image",
",",
"src",
"image",
".",
"Image",
")",
"error",
"{",
"// Scale down src in the dimension that is closer to dst.",
"sb",
":=",
"src",
".",
"Bounds",
"(",
")",
"\n",
"db",
":=",
"dst",
".",
"Bounds",
"(",
")",
"\n",
"rx",
":=",
"float64",
"(",
"sb",
".",
"Dx",
"(",
")",
")",
"/",
"float64",
"(",
"db",
".",
"Dx",
"(",
")",
")",
"\n",
"ry",
":=",
"float64",
"(",
"sb",
".",
"Dy",
"(",
")",
")",
"/",
"float64",
"(",
"db",
".",
"Dy",
"(",
")",
")",
"\n",
"var",
"b",
"image",
".",
"Rectangle",
"\n",
"if",
"rx",
"<",
"ry",
"{",
"b",
"=",
"image",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"db",
".",
"Dx",
"(",
")",
",",
"int",
"(",
"float64",
"(",
"sb",
".",
"Dy",
"(",
")",
")",
"/",
"rx",
")",
")",
"\n",
"}",
"else",
"{",
"b",
"=",
"image",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"int",
"(",
"float64",
"(",
"sb",
".",
"Dx",
"(",
")",
")",
"/",
"ry",
")",
",",
"db",
".",
"Dy",
"(",
")",
")",
"\n",
"}",
"\n\n",
"buf",
":=",
"image",
".",
"NewRGBA",
"(",
"b",
")",
"\n",
"if",
"err",
":=",
"Scale",
"(",
"buf",
",",
"src",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// Crop.",
"// TODO(crawshaw): improve on center-alignment.",
"var",
"pt",
"image",
".",
"Point",
"\n",
"if",
"rx",
"<",
"ry",
"{",
"pt",
".",
"Y",
"=",
"(",
"b",
".",
"Dy",
"(",
")",
"-",
"db",
".",
"Dy",
"(",
")",
")",
"/",
"2",
"\n",
"}",
"else",
"{",
"pt",
".",
"X",
"=",
"(",
"b",
".",
"Dx",
"(",
")",
"-",
"db",
".",
"Dx",
"(",
")",
")",
"/",
"2",
"\n",
"}",
"\n",
"draw",
".",
"Draw",
"(",
"dst",
",",
"db",
",",
"buf",
",",
"pt",
",",
"draw",
".",
"Src",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Thumbnail scales and crops src so it fits in dst. | [
"Thumbnail",
"scales",
"and",
"crops",
"src",
"so",
"it",
"fits",
"in",
"dst",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/thumbnail.go#L13-L41 |
13,656 | BurntSushi/graphics-go | graphics/detect/projector.go | newProjector | func newProjector(dst image.Rectangle, src image.Rectangle) *projector {
return &projector{
rx: float64(dst.Dx()) / float64(src.Dx()),
ry: float64(dst.Dy()) / float64(src.Dy()),
dx: float64(dst.Min.X - src.Min.X),
dy: float64(dst.Min.Y - src.Min.Y),
r: dst,
}
} | go | func newProjector(dst image.Rectangle, src image.Rectangle) *projector {
return &projector{
rx: float64(dst.Dx()) / float64(src.Dx()),
ry: float64(dst.Dy()) / float64(src.Dy()),
dx: float64(dst.Min.X - src.Min.X),
dy: float64(dst.Min.Y - src.Min.Y),
r: dst,
}
} | [
"func",
"newProjector",
"(",
"dst",
"image",
".",
"Rectangle",
",",
"src",
"image",
".",
"Rectangle",
")",
"*",
"projector",
"{",
"return",
"&",
"projector",
"{",
"rx",
":",
"float64",
"(",
"dst",
".",
"Dx",
"(",
")",
")",
"/",
"float64",
"(",
"src",
".",
"Dx",
"(",
")",
")",
",",
"ry",
":",
"float64",
"(",
"dst",
".",
"Dy",
"(",
")",
")",
"/",
"float64",
"(",
"src",
".",
"Dy",
"(",
")",
")",
",",
"dx",
":",
"float64",
"(",
"dst",
".",
"Min",
".",
"X",
"-",
"src",
".",
"Min",
".",
"X",
")",
",",
"dy",
":",
"float64",
"(",
"dst",
".",
"Min",
".",
"Y",
"-",
"src",
".",
"Min",
".",
"Y",
")",
",",
"r",
":",
"dst",
",",
"}",
"\n",
"}"
] | // newProjector creates a Projector with source src and target dst. | [
"newProjector",
"creates",
"a",
"Projector",
"with",
"source",
"src",
"and",
"target",
"dst",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/projector.go#L22-L30 |
13,657 | BurntSushi/graphics-go | graphics/detect/projector.go | pt | func (s *projector) pt(p image.Point) image.Point {
return image.Point{
clamp(s.rx*float64(p.X)+s.dx, s.r.Min.X, s.r.Max.X),
clamp(s.ry*float64(p.Y)+s.dy, s.r.Min.Y, s.r.Max.Y),
}
} | go | func (s *projector) pt(p image.Point) image.Point {
return image.Point{
clamp(s.rx*float64(p.X)+s.dx, s.r.Min.X, s.r.Max.X),
clamp(s.ry*float64(p.Y)+s.dy, s.r.Min.Y, s.r.Max.Y),
}
} | [
"func",
"(",
"s",
"*",
"projector",
")",
"pt",
"(",
"p",
"image",
".",
"Point",
")",
"image",
".",
"Point",
"{",
"return",
"image",
".",
"Point",
"{",
"clamp",
"(",
"s",
".",
"rx",
"*",
"float64",
"(",
"p",
".",
"X",
")",
"+",
"s",
".",
"dx",
",",
"s",
".",
"r",
".",
"Min",
".",
"X",
",",
"s",
".",
"r",
".",
"Max",
".",
"X",
")",
",",
"clamp",
"(",
"s",
".",
"ry",
"*",
"float64",
"(",
"p",
".",
"Y",
")",
"+",
"s",
".",
"dy",
",",
"s",
".",
"r",
".",
"Min",
".",
"Y",
",",
"s",
".",
"r",
".",
"Max",
".",
"Y",
")",
",",
"}",
"\n",
"}"
] | // pt projects p from the source rectangle onto the target rectangle. | [
"pt",
"projects",
"p",
"from",
"the",
"source",
"rectangle",
"onto",
"the",
"target",
"rectangle",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/projector.go#L33-L38 |
13,658 | BurntSushi/graphics-go | graphics/detect/projector.go | rect | func (s *projector) rect(r image.Rectangle) image.Rectangle {
return image.Rectangle{s.pt(r.Min), s.pt(r.Max)}
} | go | func (s *projector) rect(r image.Rectangle) image.Rectangle {
return image.Rectangle{s.pt(r.Min), s.pt(r.Max)}
} | [
"func",
"(",
"s",
"*",
"projector",
")",
"rect",
"(",
"r",
"image",
".",
"Rectangle",
")",
"image",
".",
"Rectangle",
"{",
"return",
"image",
".",
"Rectangle",
"{",
"s",
".",
"pt",
"(",
"r",
".",
"Min",
")",
",",
"s",
".",
"pt",
"(",
"r",
".",
"Max",
")",
"}",
"\n",
"}"
] | // rect projects r from the source rectangle onto the target rectangle. | [
"rect",
"projects",
"r",
"from",
"the",
"source",
"rectangle",
"onto",
"the",
"target",
"rectangle",
"."
] | b43f31a4a96688fba0b612e25e22648b9267e498 | https://github.com/BurntSushi/graphics-go/blob/b43f31a4a96688fba0b612e25e22648b9267e498/graphics/detect/projector.go#L41-L43 |
13,659 | 0x19/goesl | server.go | Start | func (s *OutboundServer) Start() error {
Notice("Starting Freeswitch Outbound Server @ (address: %s) ...", s.Addr)
var err error
s.Listener, err = net.Listen(s.Proto, s.Addr)
if err != nil {
Error(ECouldNotStartListener, err)
return err
}
quit := make(chan bool)
go func() {
for {
Warning("Waiting for incoming connections ...")
c, err := s.Accept()
if err != nil {
Error(EListenerConnection, err)
quit <- true
break
}
conn := SocketConnection{
Conn: c,
err: make(chan error),
m: make(chan *Message),
}
Notice("Got new connection from: %s", conn.OriginatorAddr())
go conn.Handle()
s.Conns <- conn
}
}()
<-quit
// Stopping server itself ...
s.Stop()
return err
} | go | func (s *OutboundServer) Start() error {
Notice("Starting Freeswitch Outbound Server @ (address: %s) ...", s.Addr)
var err error
s.Listener, err = net.Listen(s.Proto, s.Addr)
if err != nil {
Error(ECouldNotStartListener, err)
return err
}
quit := make(chan bool)
go func() {
for {
Warning("Waiting for incoming connections ...")
c, err := s.Accept()
if err != nil {
Error(EListenerConnection, err)
quit <- true
break
}
conn := SocketConnection{
Conn: c,
err: make(chan error),
m: make(chan *Message),
}
Notice("Got new connection from: %s", conn.OriginatorAddr())
go conn.Handle()
s.Conns <- conn
}
}()
<-quit
// Stopping server itself ...
s.Stop()
return err
} | [
"func",
"(",
"s",
"*",
"OutboundServer",
")",
"Start",
"(",
")",
"error",
"{",
"Notice",
"(",
"\"",
"\"",
",",
"s",
".",
"Addr",
")",
"\n\n",
"var",
"err",
"error",
"\n\n",
"s",
".",
"Listener",
",",
"err",
"=",
"net",
".",
"Listen",
"(",
"s",
".",
"Proto",
",",
"s",
".",
"Addr",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"Error",
"(",
"ECouldNotStartListener",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"quit",
":=",
"make",
"(",
"chan",
"bool",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"Warning",
"(",
"\"",
"\"",
")",
"\n\n",
"c",
",",
"err",
":=",
"s",
".",
"Accept",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"Error",
"(",
"EListenerConnection",
",",
"err",
")",
"\n",
"quit",
"<-",
"true",
"\n",
"break",
"\n",
"}",
"\n\n",
"conn",
":=",
"SocketConnection",
"{",
"Conn",
":",
"c",
",",
"err",
":",
"make",
"(",
"chan",
"error",
")",
",",
"m",
":",
"make",
"(",
"chan",
"*",
"Message",
")",
",",
"}",
"\n\n",
"Notice",
"(",
"\"",
"\"",
",",
"conn",
".",
"OriginatorAddr",
"(",
")",
")",
"\n\n",
"go",
"conn",
".",
"Handle",
"(",
")",
"\n\n",
"s",
".",
"Conns",
"<-",
"conn",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"<-",
"quit",
"\n\n",
"// Stopping server itself ...",
"s",
".",
"Stop",
"(",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // Start - Will start new outbound server | [
"Start",
"-",
"Will",
"start",
"new",
"outbound",
"server"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/server.go#L28-L74 |
13,660 | 0x19/goesl | server.go | NewOutboundServer | func NewOutboundServer(addr string) (*OutboundServer, error) {
if len(addr) < 2 {
addr = os.Getenv("GOESL_OUTBOUND_SERVER_ADDR")
if addr == "" {
return nil, fmt.Errorf(EInvalidServerAddr, addr)
}
}
server := OutboundServer{
Addr: addr,
Proto: "tcp",
Conns: make(chan SocketConnection),
}
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
signal.Notify(sig, syscall.SIGTERM)
go func() {
<-sig
server.Stop()
os.Exit(1)
}()
return &server, nil
} | go | func NewOutboundServer(addr string) (*OutboundServer, error) {
if len(addr) < 2 {
addr = os.Getenv("GOESL_OUTBOUND_SERVER_ADDR")
if addr == "" {
return nil, fmt.Errorf(EInvalidServerAddr, addr)
}
}
server := OutboundServer{
Addr: addr,
Proto: "tcp",
Conns: make(chan SocketConnection),
}
sig := make(chan os.Signal, 1)
signal.Notify(sig, os.Interrupt)
signal.Notify(sig, syscall.SIGTERM)
go func() {
<-sig
server.Stop()
os.Exit(1)
}()
return &server, nil
} | [
"func",
"NewOutboundServer",
"(",
"addr",
"string",
")",
"(",
"*",
"OutboundServer",
",",
"error",
")",
"{",
"if",
"len",
"(",
"addr",
")",
"<",
"2",
"{",
"addr",
"=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"addr",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"EInvalidServerAddr",
",",
"addr",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"server",
":=",
"OutboundServer",
"{",
"Addr",
":",
"addr",
",",
"Proto",
":",
"\"",
"\"",
",",
"Conns",
":",
"make",
"(",
"chan",
"SocketConnection",
")",
",",
"}",
"\n\n",
"sig",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"1",
")",
"\n\n",
"signal",
".",
"Notify",
"(",
"sig",
",",
"os",
".",
"Interrupt",
")",
"\n",
"signal",
".",
"Notify",
"(",
"sig",
",",
"syscall",
".",
"SIGTERM",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"<-",
"sig",
"\n",
"server",
".",
"Stop",
"(",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"(",
")",
"\n\n",
"return",
"&",
"server",
",",
"nil",
"\n",
"}"
] | // NewOutboundServer - Will instanciate new outbound server | [
"NewOutboundServer",
"-",
"Will",
"instanciate",
"new",
"outbound",
"server"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/server.go#L83-L110 |
13,661 | 0x19/goesl | message.go | String | func (m *Message) String() string {
return fmt.Sprintf("%v body=%s", m.Headers, m.Body)
} | go | func (m *Message) String() string {
return fmt.Sprintf("%v body=%s", m.Headers, m.Body)
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"Headers",
",",
"m",
".",
"Body",
")",
"\n",
"}"
] | // String - Will return message representation as string | [
"String",
"-",
"Will",
"return",
"message",
"representation",
"as",
"string"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/message.go#L33-L35 |
13,662 | 0x19/goesl | message.go | Dump | func (m *Message) Dump() (resp string) {
var keys []string
for k := range m.Headers {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
resp += fmt.Sprintf("%s: %s\r\n", k, m.Headers[k])
}
resp += fmt.Sprintf("BODY: %v\r\n", string(m.Body))
return
} | go | func (m *Message) Dump() (resp string) {
var keys []string
for k := range m.Headers {
keys = append(keys, k)
}
sort.Strings(keys)
for _, k := range keys {
resp += fmt.Sprintf("%s: %s\r\n", k, m.Headers[k])
}
resp += fmt.Sprintf("BODY: %v\r\n", string(m.Body))
return
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"Dump",
"(",
")",
"(",
"resp",
"string",
")",
"{",
"var",
"keys",
"[",
"]",
"string",
"\n\n",
"for",
"k",
":=",
"range",
"m",
".",
"Headers",
"{",
"keys",
"=",
"append",
"(",
"keys",
",",
"k",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"keys",
")",
"\n\n",
"for",
"_",
",",
"k",
":=",
"range",
"keys",
"{",
"resp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\r",
"\\n",
"\"",
",",
"k",
",",
"m",
".",
"Headers",
"[",
"k",
"]",
")",
"\n",
"}",
"\n\n",
"resp",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\r",
"\\n",
"\"",
",",
"string",
"(",
"m",
".",
"Body",
")",
")",
"\n\n",
"return",
"\n",
"}"
] | // Dump - Will return message prepared to be dumped out. It's like prettify message for output | [
"Dump",
"-",
"Will",
"return",
"message",
"prepared",
"to",
"be",
"dumped",
"out",
".",
"It",
"s",
"like",
"prettify",
"message",
"for",
"output"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/message.go#L182-L198 |
13,663 | 0x19/goesl | connection.go | Dial | func (c *SocketConnection) Dial(network string, addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout(network, addr, timeout)
} | go | func (c *SocketConnection) Dial(network string, addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout(network, addr, timeout)
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"Dial",
"(",
"network",
"string",
",",
"addr",
"string",
",",
"timeout",
"time",
".",
"Duration",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"return",
"net",
".",
"DialTimeout",
"(",
"network",
",",
"addr",
",",
"timeout",
")",
"\n",
"}"
] | // Dial - Will establish timedout dial against specified address. In this case, it will be freeswitch server | [
"Dial",
"-",
"Will",
"establish",
"timedout",
"dial",
"against",
"specified",
"address",
".",
"In",
"this",
"case",
"it",
"will",
"be",
"freeswitch",
"server"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L30-L32 |
13,664 | 0x19/goesl | connection.go | Send | func (c *SocketConnection) Send(cmd string) error {
if strings.Contains(cmd, "\r\n") {
return fmt.Errorf(EInvalidCommandProvided, cmd)
}
// lock mutex
c.mtx.Lock()
defer c.mtx.Unlock()
_, err := io.WriteString(c, cmd)
if err != nil {
return err
}
_, err = io.WriteString(c, "\r\n\r\n")
if err != nil {
return err
}
return nil
} | go | func (c *SocketConnection) Send(cmd string) error {
if strings.Contains(cmd, "\r\n") {
return fmt.Errorf(EInvalidCommandProvided, cmd)
}
// lock mutex
c.mtx.Lock()
defer c.mtx.Unlock()
_, err := io.WriteString(c, cmd)
if err != nil {
return err
}
_, err = io.WriteString(c, "\r\n\r\n")
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"Send",
"(",
"cmd",
"string",
")",
"error",
"{",
"if",
"strings",
".",
"Contains",
"(",
"cmd",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"EInvalidCommandProvided",
",",
"cmd",
")",
"\n",
"}",
"\n\n",
"// lock mutex",
"c",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"c",
",",
"cmd",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"c",
",",
"\"",
"\\r",
"\\n",
"\\r",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Send - Will send raw message to open net connection | [
"Send",
"-",
"Will",
"send",
"raw",
"message",
"to",
"open",
"net",
"connection"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L35-L56 |
13,665 | 0x19/goesl | connection.go | SendMany | func (c *SocketConnection) SendMany(cmds []string) error {
for _, cmd := range cmds {
if err := c.Send(cmd); err != nil {
return err
}
}
return nil
} | go | func (c *SocketConnection) SendMany(cmds []string) error {
for _, cmd := range cmds {
if err := c.Send(cmd); err != nil {
return err
}
}
return nil
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"SendMany",
"(",
"cmds",
"[",
"]",
"string",
")",
"error",
"{",
"for",
"_",
",",
"cmd",
":=",
"range",
"cmds",
"{",
"if",
"err",
":=",
"c",
".",
"Send",
"(",
"cmd",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SendMany - Will loop against passed commands and return 1st error if error happens | [
"SendMany",
"-",
"Will",
"loop",
"against",
"passed",
"commands",
"and",
"return",
"1st",
"error",
"if",
"error",
"happens"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L59-L68 |
13,666 | 0x19/goesl | connection.go | SendEvent | func (c *SocketConnection) SendEvent(eventHeaders []string) error {
if len(eventHeaders) <= 0 {
return fmt.Errorf(ECouldNotSendEvent, len(eventHeaders))
}
// lock mutex to prevent event headers from conflicting
c.mtx.Lock()
defer c.mtx.Unlock()
_, err := io.WriteString(c, "sendevent ")
if err != nil {
return err
}
for _, eventHeader := range eventHeaders {
_, err := io.WriteString(c, eventHeader)
if err != nil {
return err
}
_, err = io.WriteString(c, "\r\n")
if err != nil {
return err
}
}
_, err = io.WriteString(c, "\r\n")
if err != nil {
return err
}
return nil
} | go | func (c *SocketConnection) SendEvent(eventHeaders []string) error {
if len(eventHeaders) <= 0 {
return fmt.Errorf(ECouldNotSendEvent, len(eventHeaders))
}
// lock mutex to prevent event headers from conflicting
c.mtx.Lock()
defer c.mtx.Unlock()
_, err := io.WriteString(c, "sendevent ")
if err != nil {
return err
}
for _, eventHeader := range eventHeaders {
_, err := io.WriteString(c, eventHeader)
if err != nil {
return err
}
_, err = io.WriteString(c, "\r\n")
if err != nil {
return err
}
}
_, err = io.WriteString(c, "\r\n")
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"SendEvent",
"(",
"eventHeaders",
"[",
"]",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"eventHeaders",
")",
"<=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"ECouldNotSendEvent",
",",
"len",
"(",
"eventHeaders",
")",
")",
"\n",
"}",
"\n\n",
"// lock mutex to prevent event headers from conflicting",
"c",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"c",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"eventHeader",
":=",
"range",
"eventHeaders",
"{",
"_",
",",
"err",
":=",
"io",
".",
"WriteString",
"(",
"c",
",",
"eventHeader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"c",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"c",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // SendEvent - Will loop against passed event headers | [
"SendEvent",
"-",
"Will",
"loop",
"against",
"passed",
"event",
"headers"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L71-L104 |
13,667 | 0x19/goesl | connection.go | SendMsg | func (c *SocketConnection) SendMsg(msg map[string]string, uuid, data string) (m *Message, err error) {
b := bytes.NewBufferString("sendmsg")
if uuid != "" {
if strings.Contains(uuid, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
b.WriteString(" " + uuid)
}
b.WriteString("\n")
for k, v := range msg {
if strings.Contains(k, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
if v != "" {
if strings.Contains(v, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
b.WriteString(fmt.Sprintf("%s: %s\n", k, v))
}
}
b.WriteString("\n")
if msg["content-length"] != "" && data != "" {
b.WriteString(data)
}
// lock mutex
c.mtx.Lock()
_, err = b.WriteTo(c)
if err != nil {
c.mtx.Unlock()
return nil, err
}
c.mtx.Unlock()
select {
case err := <-c.err:
return nil, err
case m := <-c.m:
return m, nil
}
} | go | func (c *SocketConnection) SendMsg(msg map[string]string, uuid, data string) (m *Message, err error) {
b := bytes.NewBufferString("sendmsg")
if uuid != "" {
if strings.Contains(uuid, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
b.WriteString(" " + uuid)
}
b.WriteString("\n")
for k, v := range msg {
if strings.Contains(k, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
if v != "" {
if strings.Contains(v, "\r\n") {
return nil, fmt.Errorf(EInvalidCommandProvided, msg)
}
b.WriteString(fmt.Sprintf("%s: %s\n", k, v))
}
}
b.WriteString("\n")
if msg["content-length"] != "" && data != "" {
b.WriteString(data)
}
// lock mutex
c.mtx.Lock()
_, err = b.WriteTo(c)
if err != nil {
c.mtx.Unlock()
return nil, err
}
c.mtx.Unlock()
select {
case err := <-c.err:
return nil, err
case m := <-c.m:
return m, nil
}
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"SendMsg",
"(",
"msg",
"map",
"[",
"string",
"]",
"string",
",",
"uuid",
",",
"data",
"string",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"b",
":=",
"bytes",
".",
"NewBufferString",
"(",
"\"",
"\"",
")",
"\n\n",
"if",
"uuid",
"!=",
"\"",
"\"",
"{",
"if",
"strings",
".",
"Contains",
"(",
"uuid",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"EInvalidCommandProvided",
",",
"msg",
")",
"\n",
"}",
"\n\n",
"b",
".",
"WriteString",
"(",
"\"",
"\"",
"+",
"uuid",
")",
"\n",
"}",
"\n\n",
"b",
".",
"WriteString",
"(",
"\"",
"\\n",
"\"",
")",
"\n\n",
"for",
"k",
",",
"v",
":=",
"range",
"msg",
"{",
"if",
"strings",
".",
"Contains",
"(",
"k",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"EInvalidCommandProvided",
",",
"msg",
")",
"\n",
"}",
"\n\n",
"if",
"v",
"!=",
"\"",
"\"",
"{",
"if",
"strings",
".",
"Contains",
"(",
"v",
",",
"\"",
"\\r",
"\\n",
"\"",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"EInvalidCommandProvided",
",",
"msg",
")",
"\n",
"}",
"\n\n",
"b",
".",
"WriteString",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\"",
",",
"k",
",",
"v",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"b",
".",
"WriteString",
"(",
"\"",
"\\n",
"\"",
")",
"\n\n",
"if",
"msg",
"[",
"\"",
"\"",
"]",
"!=",
"\"",
"\"",
"&&",
"data",
"!=",
"\"",
"\"",
"{",
"b",
".",
"WriteString",
"(",
"data",
")",
"\n",
"}",
"\n\n",
"// lock mutex",
"c",
".",
"mtx",
".",
"Lock",
"(",
")",
"\n",
"_",
",",
"err",
"=",
"b",
".",
"WriteTo",
"(",
"c",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"c",
".",
"mtx",
".",
"Unlock",
"(",
")",
"\n\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"c",
".",
"err",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"m",
":=",
"<-",
"c",
".",
"m",
":",
"return",
"m",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // SendMsg - Basically this func will send message to the opened connection | [
"SendMsg",
"-",
"Basically",
"this",
"func",
"will",
"send",
"message",
"to",
"the",
"opened",
"connection"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L127-L176 |
13,668 | 0x19/goesl | connection.go | ReadMessage | func (c *SocketConnection) ReadMessage() (*Message, error) {
Debug("Waiting for connection message to be received ...")
select {
case err := <-c.err:
return nil, err
case msg := <-c.m:
return msg, nil
}
} | go | func (c *SocketConnection) ReadMessage() (*Message, error) {
Debug("Waiting for connection message to be received ...")
select {
case err := <-c.err:
return nil, err
case msg := <-c.m:
return msg, nil
}
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"ReadMessage",
"(",
")",
"(",
"*",
"Message",
",",
"error",
")",
"{",
"Debug",
"(",
"\"",
"\"",
")",
"\n\n",
"select",
"{",
"case",
"err",
":=",
"<-",
"c",
".",
"err",
":",
"return",
"nil",
",",
"err",
"\n",
"case",
"msg",
":=",
"<-",
"c",
".",
"m",
":",
"return",
"msg",
",",
"nil",
"\n",
"}",
"\n",
"}"
] | // ReadMessage - Will read message from channels and return them back accordingy.
// If error is received, error will be returned. If not, message will be returned back! | [
"ReadMessage",
"-",
"Will",
"read",
"message",
"from",
"channels",
"and",
"return",
"them",
"back",
"accordingy",
".",
"If",
"error",
"is",
"received",
"error",
"will",
"be",
"returned",
".",
"If",
"not",
"message",
"will",
"be",
"returned",
"back!"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L186-L195 |
13,669 | 0x19/goesl | connection.go | Handle | func (c *SocketConnection) Handle() {
done := make(chan bool)
go func() {
for {
msg, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), true)
if err != nil {
c.err <- err
done <- true
break
}
c.m <- msg
}
}()
<-done
// Closing the connection now as there's nothing left to do ...
c.Close()
} | go | func (c *SocketConnection) Handle() {
done := make(chan bool)
go func() {
for {
msg, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), true)
if err != nil {
c.err <- err
done <- true
break
}
c.m <- msg
}
}()
<-done
// Closing the connection now as there's nothing left to do ...
c.Close()
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"Handle",
"(",
")",
"{",
"done",
":=",
"make",
"(",
"chan",
"bool",
")",
"\n\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"msg",
",",
"err",
":=",
"newMessage",
"(",
"bufio",
".",
"NewReaderSize",
"(",
"c",
",",
"ReadBufferSize",
")",
",",
"true",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"c",
".",
"err",
"<-",
"err",
"\n",
"done",
"<-",
"true",
"\n",
"break",
"\n",
"}",
"\n\n",
"c",
".",
"m",
"<-",
"msg",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n\n",
"<-",
"done",
"\n\n",
"// Closing the connection now as there's nothing left to do ...",
"c",
".",
"Close",
"(",
")",
"\n",
"}"
] | // Handle - Will handle new messages and close connection when there are no messages left to process | [
"Handle",
"-",
"Will",
"handle",
"new",
"messages",
"and",
"close",
"connection",
"when",
"there",
"are",
"no",
"messages",
"left",
"to",
"process"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L198-L220 |
13,670 | 0x19/goesl | connection.go | Close | func (c *SocketConnection) Close() error {
if err := c.Conn.Close(); err != nil {
return err
}
return nil
} | go | func (c *SocketConnection) Close() error {
if err := c.Conn.Close(); err != nil {
return err
}
return nil
} | [
"func",
"(",
"c",
"*",
"SocketConnection",
")",
"Close",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"Conn",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Close - Will close down net connection and return error if error happen | [
"Close",
"-",
"Will",
"close",
"down",
"net",
"connection",
"and",
"return",
"error",
"if",
"error",
"happen"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/connection.go#L223-L229 |
13,671 | 0x19/goesl | helpers.go | ExecuteSet | func (sc *SocketConnection) ExecuteSet(key string, value string, sync bool) (m *Message, err error) {
return sc.Execute("set", key+"="+value, sync)
} | go | func (sc *SocketConnection) ExecuteSet(key string, value string, sync bool) (m *Message, err error) {
return sc.Execute("set", key+"="+value, sync)
} | [
"func",
"(",
"sc",
"*",
"SocketConnection",
")",
"ExecuteSet",
"(",
"key",
"string",
",",
"value",
"string",
",",
"sync",
"bool",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"return",
"sc",
".",
"Execute",
"(",
"\"",
"\"",
",",
"key",
"+",
"\"",
"\"",
"+",
"value",
",",
"sync",
")",
"\n",
"}"
] | // Set - Helper that you can use to execute SET application against active ESL session | [
"Set",
"-",
"Helper",
"that",
"you",
"can",
"use",
"to",
"execute",
"SET",
"application",
"against",
"active",
"ESL",
"session"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/helpers.go#L10-L12 |
13,672 | 0x19/goesl | helpers.go | ExecuteAnswer | func (sc *SocketConnection) ExecuteAnswer(args string, sync bool) (m *Message, err error) {
return sc.Execute("answer", args, sync)
} | go | func (sc *SocketConnection) ExecuteAnswer(args string, sync bool) (m *Message, err error) {
return sc.Execute("answer", args, sync)
} | [
"func",
"(",
"sc",
"*",
"SocketConnection",
")",
"ExecuteAnswer",
"(",
"args",
"string",
",",
"sync",
"bool",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"return",
"sc",
".",
"Execute",
"(",
"\"",
"\"",
",",
"args",
",",
"sync",
")",
"\n",
"}"
] | // ExecuteHangup - Helper desgned to help with executing Answer against active ESL session | [
"ExecuteHangup",
"-",
"Helper",
"desgned",
"to",
"help",
"with",
"executing",
"Answer",
"against",
"active",
"ESL",
"session"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/helpers.go#L15-L17 |
13,673 | 0x19/goesl | helpers.go | ExecuteHangup | func (sc *SocketConnection) ExecuteHangup(uuid string, args string, sync bool) (m *Message, err error) {
if uuid != "" {
return sc.ExecuteUUID(uuid, "hangup", args, sync)
}
return sc.Execute("hangup", args, sync)
} | go | func (sc *SocketConnection) ExecuteHangup(uuid string, args string, sync bool) (m *Message, err error) {
if uuid != "" {
return sc.ExecuteUUID(uuid, "hangup", args, sync)
}
return sc.Execute("hangup", args, sync)
} | [
"func",
"(",
"sc",
"*",
"SocketConnection",
")",
"ExecuteHangup",
"(",
"uuid",
"string",
",",
"args",
"string",
",",
"sync",
"bool",
")",
"(",
"m",
"*",
"Message",
",",
"err",
"error",
")",
"{",
"if",
"uuid",
"!=",
"\"",
"\"",
"{",
"return",
"sc",
".",
"ExecuteUUID",
"(",
"uuid",
",",
"\"",
"\"",
",",
"args",
",",
"sync",
")",
"\n",
"}",
"\n\n",
"return",
"sc",
".",
"Execute",
"(",
"\"",
"\"",
",",
"args",
",",
"sync",
")",
"\n",
"}"
] | // ExecuteHangup - Helper desgned to help with executing Hangup against active ESL session | [
"ExecuteHangup",
"-",
"Helper",
"desgned",
"to",
"help",
"with",
"executing",
"Hangup",
"against",
"active",
"ESL",
"session"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/helpers.go#L20-L26 |
13,674 | 0x19/goesl | examples/client.go | main | func main() {
// Boost it as much as it can go ...
runtime.GOMAXPROCS(runtime.NumCPU())
client, err := NewClient(*fshost, *fsport, *password, *timeout)
if err != nil {
Error("Error while creating new client: %s", err)
return
}
Debug("Yuhu! New client: %q", client)
// Apparently all is good... Let us now handle connection :)
// We don't want this to be inside of new connection as who knows where it my lead us.
// Remember that this is crutial part in handling incoming messages :)
go client.Handle()
client.Send("events json ALL")
client.BgApi(fmt.Sprintf("originate %s %s", "sofia/internal/[email protected]", "&socket(192.168.1.2:8084 async full)"))
for {
msg, err := client.ReadMessage()
if err != nil {
// If it contains EOF, we really dont care...
if !strings.Contains(err.Error(), "EOF") && err.Error() != "unexpected end of JSON input" {
Error("Error while reading Freeswitch message: %s", err)
}
break
}
Debug("%s", msg)
}
} | go | func main() {
// Boost it as much as it can go ...
runtime.GOMAXPROCS(runtime.NumCPU())
client, err := NewClient(*fshost, *fsport, *password, *timeout)
if err != nil {
Error("Error while creating new client: %s", err)
return
}
Debug("Yuhu! New client: %q", client)
// Apparently all is good... Let us now handle connection :)
// We don't want this to be inside of new connection as who knows where it my lead us.
// Remember that this is crutial part in handling incoming messages :)
go client.Handle()
client.Send("events json ALL")
client.BgApi(fmt.Sprintf("originate %s %s", "sofia/internal/[email protected]", "&socket(192.168.1.2:8084 async full)"))
for {
msg, err := client.ReadMessage()
if err != nil {
// If it contains EOF, we really dont care...
if !strings.Contains(err.Error(), "EOF") && err.Error() != "unexpected end of JSON input" {
Error("Error while reading Freeswitch message: %s", err)
}
break
}
Debug("%s", msg)
}
} | [
"func",
"main",
"(",
")",
"{",
"// Boost it as much as it can go ...",
"runtime",
".",
"GOMAXPROCS",
"(",
"runtime",
".",
"NumCPU",
"(",
")",
")",
"\n\n",
"client",
",",
"err",
":=",
"NewClient",
"(",
"*",
"fshost",
",",
"*",
"fsport",
",",
"*",
"password",
",",
"*",
"timeout",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"Error",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n\n",
"Debug",
"(",
"\"",
"\"",
",",
"client",
")",
"\n\n",
"// Apparently all is good... Let us now handle connection :)",
"// We don't want this to be inside of new connection as who knows where it my lead us.",
"// Remember that this is crutial part in handling incoming messages :)",
"go",
"client",
".",
"Handle",
"(",
")",
"\n\n",
"client",
".",
"Send",
"(",
"\"",
"\"",
")",
"\n\n",
"client",
".",
"BgApi",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
")",
"\n\n",
"for",
"{",
"msg",
",",
"err",
":=",
"client",
".",
"ReadMessage",
"(",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"// If it contains EOF, we really dont care...",
"if",
"!",
"strings",
".",
"Contains",
"(",
"err",
".",
"Error",
"(",
")",
",",
"\"",
"\"",
")",
"&&",
"err",
".",
"Error",
"(",
")",
"!=",
"\"",
"\"",
"{",
"Error",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"break",
"\n",
"}",
"\n\n",
"Debug",
"(",
"\"",
"\"",
",",
"msg",
")",
"\n",
"}",
"\n",
"}"
] | // Small client that will first make sure all events are returned as JSON and second, will originate | [
"Small",
"client",
"that",
"will",
"first",
"make",
"sure",
"all",
"events",
"are",
"returned",
"as",
"JSON",
"and",
"second",
"will",
"originate"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/examples/client.go#L25-L62 |
13,675 | 0x19/goesl | client.go | EstablishConnection | func (c *Client) EstablishConnection() error {
conn, err := c.Dial(c.Proto, c.Addr, time.Duration(c.Timeout*int(time.Second)))
if err != nil {
return err
}
c.SocketConnection = SocketConnection{
Conn: conn,
err: make(chan error),
m: make(chan *Message),
}
return nil
} | go | func (c *Client) EstablishConnection() error {
conn, err := c.Dial(c.Proto, c.Addr, time.Duration(c.Timeout*int(time.Second)))
if err != nil {
return err
}
c.SocketConnection = SocketConnection{
Conn: conn,
err: make(chan error),
m: make(chan *Message),
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"EstablishConnection",
"(",
")",
"error",
"{",
"conn",
",",
"err",
":=",
"c",
".",
"Dial",
"(",
"c",
".",
"Proto",
",",
"c",
".",
"Addr",
",",
"time",
".",
"Duration",
"(",
"c",
".",
"Timeout",
"*",
"int",
"(",
"time",
".",
"Second",
")",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"c",
".",
"SocketConnection",
"=",
"SocketConnection",
"{",
"Conn",
":",
"conn",
",",
"err",
":",
"make",
"(",
"chan",
"error",
")",
",",
"m",
":",
"make",
"(",
"chan",
"*",
"Message",
")",
",",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // EstablishConnection - Will attempt to establish connection against freeswitch and create new SocketConnection | [
"EstablishConnection",
"-",
"Will",
"attempt",
"to",
"establish",
"connection",
"against",
"freeswitch",
"and",
"create",
"new",
"SocketConnection"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/client.go#L30-L43 |
13,676 | 0x19/goesl | client.go | Authenticate | func (c *Client) Authenticate() error {
m, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), false)
if err != nil {
Error(ECouldNotCreateMessage, err)
return err
}
cmr, err := m.tr.ReadMIMEHeader()
if err != nil && err.Error() != "EOF" {
Error(ECouldNotReadMIMEHeaders, err)
return err
}
Debug("A: %v\n", cmr)
if cmr.Get("Content-Type") != "auth/request" {
Error(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
return fmt.Errorf(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
}
s := "auth " + c.Passwd + "\r\n\r\n"
_, err = io.WriteString(c, s)
if err != nil {
return err
}
am, err := m.tr.ReadMIMEHeader()
if err != nil && err.Error() != "EOF" {
Error(ECouldNotReadMIMEHeaders, err)
return err
}
if am.Get("Reply-Text") != "+OK accepted" {
Error(EInvalidPassword, c.Passwd)
return fmt.Errorf(EInvalidPassword, c.Passwd)
}
return nil
} | go | func (c *Client) Authenticate() error {
m, err := newMessage(bufio.NewReaderSize(c, ReadBufferSize), false)
if err != nil {
Error(ECouldNotCreateMessage, err)
return err
}
cmr, err := m.tr.ReadMIMEHeader()
if err != nil && err.Error() != "EOF" {
Error(ECouldNotReadMIMEHeaders, err)
return err
}
Debug("A: %v\n", cmr)
if cmr.Get("Content-Type") != "auth/request" {
Error(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
return fmt.Errorf(EUnexpectedAuthHeader, cmr.Get("Content-Type"))
}
s := "auth " + c.Passwd + "\r\n\r\n"
_, err = io.WriteString(c, s)
if err != nil {
return err
}
am, err := m.tr.ReadMIMEHeader()
if err != nil && err.Error() != "EOF" {
Error(ECouldNotReadMIMEHeaders, err)
return err
}
if am.Get("Reply-Text") != "+OK accepted" {
Error(EInvalidPassword, c.Passwd)
return fmt.Errorf(EInvalidPassword, c.Passwd)
}
return nil
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Authenticate",
"(",
")",
"error",
"{",
"m",
",",
"err",
":=",
"newMessage",
"(",
"bufio",
".",
"NewReaderSize",
"(",
"c",
",",
"ReadBufferSize",
")",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"Error",
"(",
"ECouldNotCreateMessage",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"cmr",
",",
"err",
":=",
"m",
".",
"tr",
".",
"ReadMIMEHeader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
".",
"Error",
"(",
")",
"!=",
"\"",
"\"",
"{",
"Error",
"(",
"ECouldNotReadMIMEHeaders",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"Debug",
"(",
"\"",
"\\n",
"\"",
",",
"cmr",
")",
"\n\n",
"if",
"cmr",
".",
"Get",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"Error",
"(",
"EUnexpectedAuthHeader",
",",
"cmr",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"EUnexpectedAuthHeader",
",",
"cmr",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
"\n",
"}",
"\n\n",
"s",
":=",
"\"",
"\"",
"+",
"c",
".",
"Passwd",
"+",
"\"",
"\\r",
"\\n",
"\\r",
"\\n",
"\"",
"\n",
"_",
",",
"err",
"=",
"io",
".",
"WriteString",
"(",
"c",
",",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"am",
",",
"err",
":=",
"m",
".",
"tr",
".",
"ReadMIMEHeader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
".",
"Error",
"(",
")",
"!=",
"\"",
"\"",
"{",
"Error",
"(",
"ECouldNotReadMIMEHeaders",
",",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"am",
".",
"Get",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"{",
"Error",
"(",
"EInvalidPassword",
",",
"c",
".",
"Passwd",
")",
"\n",
"return",
"fmt",
".",
"Errorf",
"(",
"EInvalidPassword",
",",
"c",
".",
"Passwd",
")",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] | // Authenticate - Method used to authenticate client against freeswitch. In case of any errors durring so
// we will return error. | [
"Authenticate",
"-",
"Method",
"used",
"to",
"authenticate",
"client",
"against",
"freeswitch",
".",
"In",
"case",
"of",
"any",
"errors",
"durring",
"so",
"we",
"will",
"return",
"error",
"."
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/client.go#L47-L86 |
13,677 | 0x19/goesl | client.go | NewClient | func NewClient(host string, port uint, passwd string, timeout int) (*Client, error) {
client := Client{
Proto: "tcp", // Let me know if you ever need this open up lol
Addr: net.JoinHostPort(host, strconv.Itoa(int(port))),
Passwd: passwd,
Timeout: timeout,
}
err := client.EstablishConnection()
if err != nil {
return nil, err
}
err = client.Authenticate()
if err != nil {
client.Close()
return nil, err
}
return &client, nil
} | go | func NewClient(host string, port uint, passwd string, timeout int) (*Client, error) {
client := Client{
Proto: "tcp", // Let me know if you ever need this open up lol
Addr: net.JoinHostPort(host, strconv.Itoa(int(port))),
Passwd: passwd,
Timeout: timeout,
}
err := client.EstablishConnection()
if err != nil {
return nil, err
}
err = client.Authenticate()
if err != nil {
client.Close()
return nil, err
}
return &client, nil
} | [
"func",
"NewClient",
"(",
"host",
"string",
",",
"port",
"uint",
",",
"passwd",
"string",
",",
"timeout",
"int",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"client",
":=",
"Client",
"{",
"Proto",
":",
"\"",
"\"",
",",
"// Let me know if you ever need this open up lol",
"Addr",
":",
"net",
".",
"JoinHostPort",
"(",
"host",
",",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"port",
")",
")",
")",
",",
"Passwd",
":",
"passwd",
",",
"Timeout",
":",
"timeout",
",",
"}",
"\n\n",
"err",
":=",
"client",
".",
"EstablishConnection",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"client",
".",
"Authenticate",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"client",
".",
"Close",
"(",
")",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"&",
"client",
",",
"nil",
"\n",
"}"
] | // NewClient - Will initiate new client that will establish connection and attempt to authenticate
// against connected freeswitch server | [
"NewClient",
"-",
"Will",
"initiate",
"new",
"client",
"that",
"will",
"establish",
"connection",
"and",
"attempt",
"to",
"authenticate",
"against",
"connected",
"freeswitch",
"server"
] | 54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44 | https://github.com/0x19/goesl/blob/54ed41e51fd535a1cd6ea9e729f5d4be4dc55b44/client.go#L90-L110 |
13,678 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Add | func (cli *OpsGenieHeartbeatClient) Add(req heartbeat.AddHeartbeatRequest) (*heartbeat.AddHeartbeatResponse, error) {
var response heartbeat.HeartbeatResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err;
}
result := convertAddResponseToV1Response(&response)
result.Code = 201
return result, nil
} | go | func (cli *OpsGenieHeartbeatClient) Add(req heartbeat.AddHeartbeatRequest) (*heartbeat.AddHeartbeatResponse, error) {
var response heartbeat.HeartbeatResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err;
}
result := convertAddResponseToV1Response(&response)
result.Code = 201
return result, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Add",
"(",
"req",
"heartbeat",
".",
"AddHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"AddHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatResponseV2",
"\n\n",
"err",
":=",
"cli",
".",
"sendPostRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
";",
"}",
"\n",
"result",
":=",
"convertAddResponseToV1Response",
"(",
"&",
"response",
")",
"\n",
"result",
".",
"Code",
"=",
"201",
"\n",
"return",
"result",
",",
"nil",
"\n",
"}"
] | // Add method creates a heartbeat at OpsGenie. | [
"Add",
"method",
"creates",
"a",
"heartbeat",
"at",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L26-L37 |
13,679 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Update | func (cli *OpsGenieHeartbeatClient) Update(req heartbeat.UpdateHeartbeatRequest) (*heartbeat.UpdateHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPatchRequest(&req, &response)
if err != nil {
return nil, err
}
return convertUpdateToV1Response(&response), nil
} | go | func (cli *OpsGenieHeartbeatClient) Update(req heartbeat.UpdateHeartbeatRequest) (*heartbeat.UpdateHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPatchRequest(&req, &response)
if err != nil {
return nil, err
}
return convertUpdateToV1Response(&response), nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Update",
"(",
"req",
"heartbeat",
".",
"UpdateHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"UpdateHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatMetaResponseV2",
"\n",
"err",
":=",
"cli",
".",
"sendPatchRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"convertUpdateToV1Response",
"(",
"&",
"response",
")",
",",
"nil",
"\n",
"}"
] | // Update method changes configuration of an existing heartbeat at OpsGenie. | [
"Update",
"method",
"changes",
"configuration",
"of",
"an",
"existing",
"heartbeat",
"at",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L40-L49 |
13,680 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Enable | func (cli *OpsGenieHeartbeatClient) Enable(req heartbeat.EnableHeartbeatRequest) (*heartbeat.EnableHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.EnableHeartbeatResponse
result.Status = "successful"
result.Code = 200
return &result, nil
} | go | func (cli *OpsGenieHeartbeatClient) Enable(req heartbeat.EnableHeartbeatRequest) (*heartbeat.EnableHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.EnableHeartbeatResponse
result.Status = "successful"
result.Code = 200
return &result, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Enable",
"(",
"req",
"heartbeat",
".",
"EnableHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"EnableHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatMetaResponseV2",
"\n\n",
"err",
":=",
"cli",
".",
"sendPostRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"result",
"heartbeat",
".",
"EnableHeartbeatResponse",
"\n",
"result",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"result",
".",
"Code",
"=",
"200",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"}"
] | // Enable method enables an heartbeat at OpsGenie. | [
"Enable",
"method",
"enables",
"an",
"heartbeat",
"at",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L52-L65 |
13,681 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Disable | func (cli *OpsGenieHeartbeatClient) Disable(req heartbeat.DisableHeartbeatRequest) (*heartbeat.DisableHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.DisableHeartbeatResponse
result.Status = "successful"
result.Code = 200
return &result, nil
} | go | func (cli *OpsGenieHeartbeatClient) Disable(req heartbeat.DisableHeartbeatRequest) (*heartbeat.DisableHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendPostRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.DisableHeartbeatResponse
result.Status = "successful"
result.Code = 200
return &result, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Disable",
"(",
"req",
"heartbeat",
".",
"DisableHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"DisableHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatMetaResponseV2",
"\n\n",
"err",
":=",
"cli",
".",
"sendPostRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"result",
"heartbeat",
".",
"DisableHeartbeatResponse",
"\n",
"result",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"result",
".",
"Code",
"=",
"200",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"}"
] | // Disable method disables an heartbeat at OpsGenie. | [
"Disable",
"method",
"disables",
"an",
"heartbeat",
"at",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L68-L81 |
13,682 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Delete | func (cli *OpsGenieHeartbeatClient) Delete(req heartbeat.DeleteHeartbeatRequest) (*heartbeat.DeleteHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendDeleteRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.DeleteHeartbeatResponse
result.Status = "Deleted"
result.Code = 200
return &result, nil
} | go | func (cli *OpsGenieHeartbeatClient) Delete(req heartbeat.DeleteHeartbeatRequest) (*heartbeat.DeleteHeartbeatResponse, error) {
var response heartbeat.HeartbeatMetaResponseV2
err := cli.sendDeleteRequest(&req, &response)
if err != nil {
return nil, err
}
var result heartbeat.DeleteHeartbeatResponse
result.Status = "Deleted"
result.Code = 200
return &result, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Delete",
"(",
"req",
"heartbeat",
".",
"DeleteHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"DeleteHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatMetaResponseV2",
"\n\n",
"err",
":=",
"cli",
".",
"sendDeleteRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"result",
"heartbeat",
".",
"DeleteHeartbeatResponse",
"\n",
"result",
".",
"Status",
"=",
"\"",
"\"",
"\n",
"result",
".",
"Code",
"=",
"200",
"\n",
"return",
"&",
"result",
",",
"nil",
"\n",
"}"
] | // Delete method deletes an heartbeat from OpsGenie. | [
"Delete",
"method",
"deletes",
"an",
"heartbeat",
"from",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L84-L97 |
13,683 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Get | func (cli *OpsGenieHeartbeatClient) Get(req heartbeat.GetHeartbeatRequest) (*heartbeat.GetHeartbeatResponse, error) {
var response heartbeat.HeartbeatResponseV2
err := cli.sendGetRequest(&req, &response)
if err != nil {
return nil, err
}
return convertGetToV1Response(&response), nil
} | go | func (cli *OpsGenieHeartbeatClient) Get(req heartbeat.GetHeartbeatRequest) (*heartbeat.GetHeartbeatResponse, error) {
var response heartbeat.HeartbeatResponseV2
err := cli.sendGetRequest(&req, &response)
if err != nil {
return nil, err
}
return convertGetToV1Response(&response), nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Get",
"(",
"req",
"heartbeat",
".",
"GetHeartbeatRequest",
")",
"(",
"*",
"heartbeat",
".",
"GetHeartbeatResponse",
",",
"error",
")",
"{",
"var",
"response",
"heartbeat",
".",
"HeartbeatResponseV2",
"\n\n",
"err",
":=",
"cli",
".",
"sendGetRequest",
"(",
"&",
"req",
",",
"&",
"response",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"convertGetToV1Response",
"(",
"&",
"response",
")",
",",
"nil",
"\n",
"}"
] | // Get method retrieves an heartbeat with details from OpsGenie. | [
"Get",
"method",
"retrieves",
"an",
"heartbeat",
"with",
"details",
"from",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L100-L109 |
13,684 | opsgenie/opsgenie-go-sdk | client/opsgenie_heartbeat_client.go | Ping | func (cli *OpsGenieHeartbeatClient) Ping(req heartbeat.PingHeartbeatRequest) (*AsyncRequestResponse, error) {
return cli.sendAsyncPostRequest(&req)
} | go | func (cli *OpsGenieHeartbeatClient) Ping(req heartbeat.PingHeartbeatRequest) (*AsyncRequestResponse, error) {
return cli.sendAsyncPostRequest(&req)
} | [
"func",
"(",
"cli",
"*",
"OpsGenieHeartbeatClient",
")",
"Ping",
"(",
"req",
"heartbeat",
".",
"PingHeartbeatRequest",
")",
"(",
"*",
"AsyncRequestResponse",
",",
"error",
")",
"{",
"return",
"cli",
".",
"sendAsyncPostRequest",
"(",
"&",
"req",
")",
"\n",
"}"
] | // Send method sends an Heartbeat Signal to OpsGenie. | [
"Send",
"method",
"sends",
"an",
"Heartbeat",
"Signal",
"to",
"OpsGenie",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/opsgenie_heartbeat_client.go#L152-L154 |
13,685 | opsgenie/opsgenie-go-sdk | client/client.go | ToString | func (p requestHeaderUserAgent) ToString() string {
return fmt.Sprintf("%s/%s (%s;%s;%s)", p.sdkName, p.version, p.os, p.goVersion, p.timezone)
} | go | func (p requestHeaderUserAgent) ToString() string {
return fmt.Sprintf("%s/%s (%s;%s;%s)", p.sdkName, p.version, p.os, p.goVersion, p.timezone)
} | [
"func",
"(",
"p",
"requestHeaderUserAgent",
")",
"ToString",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"sdkName",
",",
"p",
".",
"version",
",",
"p",
".",
"os",
",",
"p",
".",
"goVersion",
",",
"p",
".",
"timezone",
")",
"\n",
"}"
] | // ToString formats and returns RequestHeaderUserAgent type's fields as string. | [
"ToString",
"formats",
"and",
"returns",
"RequestHeaderUserAgent",
"type",
"s",
"fields",
"as",
"string",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L76-L78 |
13,686 | opsgenie/opsgenie-go-sdk | client/client.go | makeHTTPTransportSettings | func (cli *OpsGenieClient) makeHTTPTransportSettings() {
if cli.httpTransportSettings != nil {
if cli.httpTransportSettings.MaxRetryAttempts <= 0 {
cli.httpTransportSettings.MaxRetryAttempts = defaultMaxRetryAttempts
}
if cli.httpTransportSettings.ConnectionTimeout <= 0 {
cli.httpTransportSettings.ConnectionTimeout = defaultConnectionTimeout
}
if cli.httpTransportSettings.RequestTimeout <= 0 {
cli.httpTransportSettings.RequestTimeout = defaultRequestTimeout
}
} else {
cli.httpTransportSettings = &HTTPTransportSettings{MaxRetryAttempts: defaultMaxRetryAttempts, ConnectionTimeout: defaultConnectionTimeout, RequestTimeout: defaultRequestTimeout}
}
} | go | func (cli *OpsGenieClient) makeHTTPTransportSettings() {
if cli.httpTransportSettings != nil {
if cli.httpTransportSettings.MaxRetryAttempts <= 0 {
cli.httpTransportSettings.MaxRetryAttempts = defaultMaxRetryAttempts
}
if cli.httpTransportSettings.ConnectionTimeout <= 0 {
cli.httpTransportSettings.ConnectionTimeout = defaultConnectionTimeout
}
if cli.httpTransportSettings.RequestTimeout <= 0 {
cli.httpTransportSettings.RequestTimeout = defaultRequestTimeout
}
} else {
cli.httpTransportSettings = &HTTPTransportSettings{MaxRetryAttempts: defaultMaxRetryAttempts, ConnectionTimeout: defaultConnectionTimeout, RequestTimeout: defaultRequestTimeout}
}
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"makeHTTPTransportSettings",
"(",
")",
"{",
"if",
"cli",
".",
"httpTransportSettings",
"!=",
"nil",
"{",
"if",
"cli",
".",
"httpTransportSettings",
".",
"MaxRetryAttempts",
"<=",
"0",
"{",
"cli",
".",
"httpTransportSettings",
".",
"MaxRetryAttempts",
"=",
"defaultMaxRetryAttempts",
"\n",
"}",
"\n",
"if",
"cli",
".",
"httpTransportSettings",
".",
"ConnectionTimeout",
"<=",
"0",
"{",
"cli",
".",
"httpTransportSettings",
".",
"ConnectionTimeout",
"=",
"defaultConnectionTimeout",
"\n",
"}",
"\n",
"if",
"cli",
".",
"httpTransportSettings",
".",
"RequestTimeout",
"<=",
"0",
"{",
"cli",
".",
"httpTransportSettings",
".",
"RequestTimeout",
"=",
"defaultRequestTimeout",
"\n",
"}",
"\n",
"}",
"else",
"{",
"cli",
".",
"httpTransportSettings",
"=",
"&",
"HTTPTransportSettings",
"{",
"MaxRetryAttempts",
":",
"defaultMaxRetryAttempts",
",",
"ConnectionTimeout",
":",
"defaultConnectionTimeout",
",",
"RequestTimeout",
":",
"defaultRequestTimeout",
"}",
"\n",
"}",
"\n",
"}"
] | // makeHTTPTransportSettings internal method to set default values of HTTP transport layer configuration if necessary. | [
"makeHTTPTransportSettings",
"internal",
"method",
"to",
"set",
"default",
"values",
"of",
"HTTP",
"transport",
"layer",
"configuration",
"if",
"necessary",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L132-L146 |
13,687 | opsgenie/opsgenie-go-sdk | client/client.go | AlertV2 | func (cli *OpsGenieClient) AlertV2() (*OpsGenieAlertV2Client, error) {
cli.makeHTTPTransportSettings()
alertClient := new(OpsGenieAlertV2Client)
alertClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
alertClient.SetOpsGenieAPIUrl(endpointURL)
}
return alertClient, nil
} | go | func (cli *OpsGenieClient) AlertV2() (*OpsGenieAlertV2Client, error) {
cli.makeHTTPTransportSettings()
alertClient := new(OpsGenieAlertV2Client)
alertClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
alertClient.SetOpsGenieAPIUrl(endpointURL)
}
return alertClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"AlertV2",
"(",
")",
"(",
"*",
"OpsGenieAlertV2Client",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"alertClient",
":=",
"new",
"(",
"OpsGenieAlertV2Client",
")",
"\n",
"alertClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"alertClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"alertClient",
",",
"nil",
"\n",
"}"
] | // AlertV2 instantiates a new OpsGenieAlertV2Client. | [
"AlertV2",
"instantiates",
"a",
"new",
"OpsGenieAlertV2Client",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L164-L175 |
13,688 | opsgenie/opsgenie-go-sdk | client/client.go | Contact | func (cli *OpsGenieClient) Contact() (*OpsGenieContactClient, error) {
cli.makeHTTPTransportSettings()
contactClient := new(OpsGenieContactClient)
contactClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
contactClient.SetOpsGenieAPIUrl(endpointURL)
}
return contactClient, nil
} | go | func (cli *OpsGenieClient) Contact() (*OpsGenieContactClient, error) {
cli.makeHTTPTransportSettings()
contactClient := new(OpsGenieContactClient)
contactClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
contactClient.SetOpsGenieAPIUrl(endpointURL)
}
return contactClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Contact",
"(",
")",
"(",
"*",
"OpsGenieContactClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"contactClient",
":=",
"new",
"(",
"OpsGenieContactClient",
")",
"\n",
"contactClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"contactClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"contactClient",
",",
"nil",
"\n",
"}"
] | // Alert instantiates a new OpsGenieContactClient. | [
"Alert",
"instantiates",
"a",
"new",
"OpsGenieContactClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L178-L189 |
13,689 | opsgenie/opsgenie-go-sdk | client/client.go | Heartbeat | func (cli *OpsGenieClient) Heartbeat() (*OpsGenieHeartbeatClient, error) {
cli.makeHTTPTransportSettings()
heartbeatClient := new(OpsGenieHeartbeatClient)
heartbeatClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
heartbeatClient.SetOpsGenieAPIUrl(endpointURL)
}
return heartbeatClient, nil
} | go | func (cli *OpsGenieClient) Heartbeat() (*OpsGenieHeartbeatClient, error) {
cli.makeHTTPTransportSettings()
heartbeatClient := new(OpsGenieHeartbeatClient)
heartbeatClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
heartbeatClient.SetOpsGenieAPIUrl(endpointURL)
}
return heartbeatClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Heartbeat",
"(",
")",
"(",
"*",
"OpsGenieHeartbeatClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"heartbeatClient",
":=",
"new",
"(",
"OpsGenieHeartbeatClient",
")",
"\n",
"heartbeatClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"heartbeatClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"heartbeatClient",
",",
"nil",
"\n",
"}"
] | // Heartbeat instantiates a new OpsGenieHeartbeatClient. | [
"Heartbeat",
"instantiates",
"a",
"new",
"OpsGenieHeartbeatClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L192-L203 |
13,690 | opsgenie/opsgenie-go-sdk | client/client.go | Integration | func (cli *OpsGenieClient) Integration() (*OpsGenieIntegrationClient, error) {
cli.makeHTTPTransportSettings()
integrationClient := new(OpsGenieIntegrationClient)
integrationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
integrationClient.SetOpsGenieAPIUrl(endpointURL)
}
return integrationClient, nil
} | go | func (cli *OpsGenieClient) Integration() (*OpsGenieIntegrationClient, error) {
cli.makeHTTPTransportSettings()
integrationClient := new(OpsGenieIntegrationClient)
integrationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
integrationClient.SetOpsGenieAPIUrl(endpointURL)
}
return integrationClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Integration",
"(",
")",
"(",
"*",
"OpsGenieIntegrationClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"integrationClient",
":=",
"new",
"(",
"OpsGenieIntegrationClient",
")",
"\n",
"integrationClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"integrationClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"integrationClient",
",",
"nil",
"\n",
"}"
] | // Integration instantiates a new OpsGenieIntegrationClient. | [
"Integration",
"instantiates",
"a",
"new",
"OpsGenieIntegrationClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L206-L217 |
13,691 | opsgenie/opsgenie-go-sdk | client/client.go | Policy | func (cli *OpsGenieClient) Policy() (*OpsGeniePolicyClient, error) {
cli.makeHTTPTransportSettings()
policyClient := new(OpsGeniePolicyClient)
policyClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
policyClient.SetOpsGenieAPIUrl(endpointURL)
}
return policyClient, nil
} | go | func (cli *OpsGenieClient) Policy() (*OpsGeniePolicyClient, error) {
cli.makeHTTPTransportSettings()
policyClient := new(OpsGeniePolicyClient)
policyClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
policyClient.SetOpsGenieAPIUrl(endpointURL)
}
return policyClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Policy",
"(",
")",
"(",
"*",
"OpsGeniePolicyClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"policyClient",
":=",
"new",
"(",
"OpsGeniePolicyClient",
")",
"\n",
"policyClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"policyClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"policyClient",
",",
"nil",
"\n",
"}"
] | // Policy instantiates a new OpsGeniePolicyClient. | [
"Policy",
"instantiates",
"a",
"new",
"OpsGeniePolicyClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L220-L231 |
13,692 | opsgenie/opsgenie-go-sdk | client/client.go | Team | func (cli *OpsGenieClient) Team() (*OpsGenieTeamClient, error) {
cli.makeHTTPTransportSettings()
teamClient := new(OpsGenieTeamClient)
teamClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
teamClient.SetOpsGenieAPIUrl(endpointURL)
}
return teamClient, nil
} | go | func (cli *OpsGenieClient) Team() (*OpsGenieTeamClient, error) {
cli.makeHTTPTransportSettings()
teamClient := new(OpsGenieTeamClient)
teamClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
teamClient.SetOpsGenieAPIUrl(endpointURL)
}
return teamClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Team",
"(",
")",
"(",
"*",
"OpsGenieTeamClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"teamClient",
":=",
"new",
"(",
"OpsGenieTeamClient",
")",
"\n",
"teamClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"teamClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"teamClient",
",",
"nil",
"\n",
"}"
] | // Team instantiates a new OpsGenieTeamClient. | [
"Team",
"instantiates",
"a",
"new",
"OpsGenieTeamClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L234-L245 |
13,693 | opsgenie/opsgenie-go-sdk | client/client.go | Escalation | func (cli *OpsGenieClient) Escalation() (*OpsGenieEscalationClient, error) {
cli.makeHTTPTransportSettings()
escalationClient := new(OpsGenieEscalationClient)
escalationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
escalationClient.SetOpsGenieAPIUrl(endpointURL)
}
return escalationClient, nil
} | go | func (cli *OpsGenieClient) Escalation() (*OpsGenieEscalationClient, error) {
cli.makeHTTPTransportSettings()
escalationClient := new(OpsGenieEscalationClient)
escalationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
escalationClient.SetOpsGenieAPIUrl(endpointURL)
}
return escalationClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Escalation",
"(",
")",
"(",
"*",
"OpsGenieEscalationClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"escalationClient",
":=",
"new",
"(",
"OpsGenieEscalationClient",
")",
"\n",
"escalationClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"escalationClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"escalationClient",
",",
"nil",
"\n",
"}"
] | // Escalation instantiates a new OpsGenieEscalationClient. | [
"Escalation",
"instantiates",
"a",
"new",
"OpsGenieEscalationClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L248-L259 |
13,694 | opsgenie/opsgenie-go-sdk | client/client.go | Schedule | func (cli *OpsGenieClient) Schedule() (*OpsGenieScheduleClient, error) {
cli.makeHTTPTransportSettings()
scheduleClient := new(OpsGenieScheduleClient)
scheduleClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleClient, nil
} | go | func (cli *OpsGenieClient) Schedule() (*OpsGenieScheduleClient, error) {
cli.makeHTTPTransportSettings()
scheduleClient := new(OpsGenieScheduleClient)
scheduleClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"Schedule",
"(",
")",
"(",
"*",
"OpsGenieScheduleClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"scheduleClient",
":=",
"new",
"(",
"OpsGenieScheduleClient",
")",
"\n",
"scheduleClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"scheduleClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"scheduleClient",
",",
"nil",
"\n",
"}"
] | // Schedule instantiates a new OpsGenieScheduleClient. | [
"Schedule",
"instantiates",
"a",
"new",
"OpsGenieScheduleClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L262-L273 |
13,695 | opsgenie/opsgenie-go-sdk | client/client.go | ScheduleOverride | func (cli *OpsGenieClient) ScheduleOverride() (*OpsGenieScheduleOverrideClient, error) {
cli.makeHTTPTransportSettings()
scheduleOverrideClient := new(OpsGenieScheduleOverrideClient)
scheduleOverrideClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleOverrideClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleOverrideClient, nil
} | go | func (cli *OpsGenieClient) ScheduleOverride() (*OpsGenieScheduleOverrideClient, error) {
cli.makeHTTPTransportSettings()
scheduleOverrideClient := new(OpsGenieScheduleOverrideClient)
scheduleOverrideClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleOverrideClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleOverrideClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"ScheduleOverride",
"(",
")",
"(",
"*",
"OpsGenieScheduleOverrideClient",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"scheduleOverrideClient",
":=",
"new",
"(",
"OpsGenieScheduleOverrideClient",
")",
"\n",
"scheduleOverrideClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"scheduleOverrideClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"scheduleOverrideClient",
",",
"nil",
"\n",
"}"
] | // ScheduleOverride instantiates a new OpsGenieScheduleOverrideClient. | [
"ScheduleOverride",
"instantiates",
"a",
"new",
"OpsGenieScheduleOverrideClient",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L276-L287 |
13,696 | opsgenie/opsgenie-go-sdk | client/client.go | UserV2 | func (cli *OpsGenieClient) UserV2() (*OpsGenieUserV2Client, error) {
cli.makeHTTPTransportSettings()
userClient := new(OpsGenieUserV2Client)
userClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
userClient.SetOpsGenieAPIUrl(endpointURL)
}
return userClient, nil
} | go | func (cli *OpsGenieClient) UserV2() (*OpsGenieUserV2Client, error) {
cli.makeHTTPTransportSettings()
userClient := new(OpsGenieUserV2Client)
userClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
userClient.SetOpsGenieAPIUrl(endpointURL)
}
return userClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"UserV2",
"(",
")",
"(",
"*",
"OpsGenieUserV2Client",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"userClient",
":=",
"new",
"(",
"OpsGenieUserV2Client",
")",
"\n",
"userClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"userClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"userClient",
",",
"nil",
"\n",
"}"
] | // UserV2 instantiates a new OpsGenieUserV2Client. | [
"UserV2",
"instantiates",
"a",
"new",
"OpsGenieUserV2Client",
"."
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L305-L316 |
13,697 | opsgenie/opsgenie-go-sdk | client/client.go | NotificationV2 | func (cli *OpsGenieClient) NotificationV2() (*OpsGenieNotificationV2Client, error) {
cli.makeHTTPTransportSettings()
notificationClient := new(OpsGenieNotificationV2Client)
notificationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
notificationClient.SetOpsGenieAPIUrl(endpointURL)
}
return notificationClient, nil
} | go | func (cli *OpsGenieClient) NotificationV2() (*OpsGenieNotificationV2Client, error) {
cli.makeHTTPTransportSettings()
notificationClient := new(OpsGenieNotificationV2Client)
notificationClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
notificationClient.SetOpsGenieAPIUrl(endpointURL)
}
return notificationClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"NotificationV2",
"(",
")",
"(",
"*",
"OpsGenieNotificationV2Client",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"notificationClient",
":=",
"new",
"(",
"OpsGenieNotificationV2Client",
")",
"\n",
"notificationClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"notificationClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"notificationClient",
",",
"nil",
"\n",
"}"
] | // NotificationV2 instantiates a new OpsGenieNotificationV2Client | [
"NotificationV2",
"instantiates",
"a",
"new",
"OpsGenieNotificationV2Client"
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L319-L330 |
13,698 | opsgenie/opsgenie-go-sdk | client/client.go | ScheduleV2 | func (cli *OpsGenieClient) ScheduleV2() (*OpsGenieScheduleV2Client, error) {
cli.makeHTTPTransportSettings()
scheduleClient := new(OpsGenieScheduleV2Client)
scheduleClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleClient, nil
} | go | func (cli *OpsGenieClient) ScheduleV2() (*OpsGenieScheduleV2Client, error) {
cli.makeHTTPTransportSettings()
scheduleClient := new(OpsGenieScheduleV2Client)
scheduleClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"ScheduleV2",
"(",
")",
"(",
"*",
"OpsGenieScheduleV2Client",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"scheduleClient",
":=",
"new",
"(",
"OpsGenieScheduleV2Client",
")",
"\n",
"scheduleClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"scheduleClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"scheduleClient",
",",
"nil",
"\n",
"}"
] | // ScheduleV2 instantiates a new OpsGenieScheduleV2Client | [
"ScheduleV2",
"instantiates",
"a",
"new",
"OpsGenieScheduleV2Client"
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L333-L344 |
13,699 | opsgenie/opsgenie-go-sdk | client/client.go | ScheduleOverrideV2 | func (cli *OpsGenieClient) ScheduleOverrideV2() (*OpsGenieScheduleOverrideV2Client, error) {
cli.makeHTTPTransportSettings()
scheduleOverrideClient := new(OpsGenieScheduleOverrideV2Client)
scheduleOverrideClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleOverrideClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleOverrideClient, nil
} | go | func (cli *OpsGenieClient) ScheduleOverrideV2() (*OpsGenieScheduleOverrideV2Client, error) {
cli.makeHTTPTransportSettings()
scheduleOverrideClient := new(OpsGenieScheduleOverrideV2Client)
scheduleOverrideClient.SetOpsGenieClient(*cli)
if cli.opsGenieAPIURL == "" {
scheduleOverrideClient.SetOpsGenieAPIUrl(endpointURL)
}
return scheduleOverrideClient, nil
} | [
"func",
"(",
"cli",
"*",
"OpsGenieClient",
")",
"ScheduleOverrideV2",
"(",
")",
"(",
"*",
"OpsGenieScheduleOverrideV2Client",
",",
"error",
")",
"{",
"cli",
".",
"makeHTTPTransportSettings",
"(",
")",
"\n\n",
"scheduleOverrideClient",
":=",
"new",
"(",
"OpsGenieScheduleOverrideV2Client",
")",
"\n",
"scheduleOverrideClient",
".",
"SetOpsGenieClient",
"(",
"*",
"cli",
")",
"\n\n",
"if",
"cli",
".",
"opsGenieAPIURL",
"==",
"\"",
"\"",
"{",
"scheduleOverrideClient",
".",
"SetOpsGenieAPIUrl",
"(",
"endpointURL",
")",
"\n",
"}",
"\n\n",
"return",
"scheduleOverrideClient",
",",
"nil",
"\n",
"}"
] | // ScheduleOverrideV2 instantiates a new OpsGenieScheduleOverrideV2Client | [
"ScheduleOverrideV2",
"instantiates",
"a",
"new",
"OpsGenieScheduleOverrideV2Client"
] | d57b8391ca905cccc085a075a2f7c1308d01cca3 | https://github.com/opsgenie/opsgenie-go-sdk/blob/d57b8391ca905cccc085a075a2f7c1308d01cca3/client/client.go#L347-L358 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.