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 list | docstring stringlengths 6 2.61k | docstring_tokens list | 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",
... | // 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... | 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",
... | // 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",
"{",
"dele... | // 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",... | // 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",
","... | // 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",
".",
... | // 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",
":=",
"filterRes... | // 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",... | // 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... | // 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",
... | // 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",
".",
"Invoca... | // 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",
"{",
"}",
"}",... | // 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",
",",
"metricsC... | // 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",
")",
",... | // 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",
"(... | // 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",
",",
... | // 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",... | // 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",
")",
",",
"expectedRequest... | // 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",
"http... | // 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"... | // 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",
"unti... | 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 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",
"!=",
"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",
"... | // 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",... | // 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",
"popu... | 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",
")... | // 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",
... | // 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",
"{",
... | // 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",
... | // 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",
"."... | // 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",
"&&",
... | // 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",
... | 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",
".",
"get... | // 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",
"fi... | 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",
",... | // 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",
"(",
"\"",
"\"",
")",
"\... | // 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",
".",... | // 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... | 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... | // 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"... | // 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",
... | // 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",
"(",
"\"",
"\"... | // 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",
"... | // 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"... | // 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",
... | // 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",
",",
"+",... | // 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",
"ful... | // 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",
"... | // 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",
"{",
"retur... | // 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",
... | // 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... | // 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",
... | // 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",
"(",... | // 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",... | // 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",... | // 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",
".",
... | // 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",
... | // 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",
"==",
"\"",
"... | // 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",
... | // 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",... | // 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",
",",... | // 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",
"... | // 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",
"(",
... | // 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",
... | // 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",
",",
"er... | // 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",
"("... | // 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",
"(",
"\"",
"\"",
",",
"k... | // 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",
"... | // 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",
... | // 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/1001@127.0.0.1", "&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/1001@127.0.0.1", "&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"... | // 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",
... | // 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",
"{",
"Er... | // 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 ne... | // 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\... | // 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",
".",
"HeartbeatMetaRespon... | // 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",
".",
"HeartbeatMetaRespon... | // 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",
".",
"HeartbeatMetaRes... | // 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",
".",
"HeartbeatMetaRespon... | // 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\... | // 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",
... | // 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",
".",
"httpTransp... | // 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",
"a... | // 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",
... | // 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",
")",
... | // 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",
... | // 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",
"pol... | // 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"... | // 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",
")"... | // 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"... | // 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",
"(",
"OpsGenieSchedu... | // 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",
"userC... | // 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",
"(",
"OpsGenieNotificationV2... | // 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",
")",
... | // 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",
"(",
"OpsGenieSc... | // 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.