query stringlengths 10 3.85k | document stringlengths 17 430k | negative_0 stringlengths 9 309k | negative_1 stringlengths 14 197k | negative_2 stringlengths 13 304k | negative_3 stringlengths 9 309k | negative_4 stringlengths 14 309k | negative_5 stringlengths 11 5.47M | negative_6 stringlengths 9 430k | negative_7 stringlengths 9 430k | negative_8 stringlengths 13 143k | negative_9 stringlengths 9 309k | negative_10 stringlengths 13 179k | negative_11 stringlengths 13 56.7k | negative_12 stringlengths 9 430k | negative_13 stringlengths 13 5.47M | negative_14 stringlengths 9 197k | negative_15 stringlengths 11 1.45M | negative_16 stringlengths 9 64k | negative_17 stringlengths 11 430k | negative_18 stringlengths 14 5.47M | negative_19 stringlengths 14 2.06M | negative_20 stringlengths 9 60k | negative_21 stringlengths 14 56.7k | negative_22 stringlengths 9 430k | negative_23 stringlengths 9 304k | negative_24 stringlengths 9 197k | negative_25 stringlengths 13 430k | negative_26 stringlengths 14 1.45M | negative_27 stringlengths 13 1.89M | negative_28 stringlengths 14 82.3k | negative_29 stringlengths 13 197k | negative_30 stringlengths 14 309k | negative_31 stringlengths 9 5.47M | negative_32 stringlengths 13 264k | negative_33 stringlengths 14 304k | negative_34 stringlengths 9 430k | negative_35 stringlengths 13 304k | negative_36 stringlengths 14 1.45M | negative_37 stringlengths 13 4.07M | negative_38 stringlengths 14 95.2k | negative_39 stringlengths 13 1.45M | negative_40 stringlengths 9 430k | negative_41 stringlengths 14 430k | negative_42 stringlengths 13 135k | negative_43 stringlengths 9 430k | negative_44 stringlengths 12 5.47M | negative_45 stringlengths 13 1.45M | negative_46 stringlengths 13 2.06M | negative_47 stringlengths 13 304k | negative_48 stringlengths 13 2.06M | negative_49 stringlengths 9 110k | negative_50 stringlengths 14 230k | negative_51 stringlengths 14 1.45M | negative_52 stringlengths 14 5.47M | negative_53 stringlengths 14 304k | negative_54 stringlengths 13 179k | negative_55 stringlengths 9 1.45M | negative_56 stringlengths 14 197k | negative_57 stringlengths 14 1.68M | negative_58 stringlengths 13 1.45M | negative_59 stringlengths 15 1.68M | negative_60 stringlengths 13 430k | negative_61 stringlengths 11 2.06M | negative_62 stringlengths 13 53.5k | negative_63 stringlengths 13 309k | negative_64 stringlengths 14 1.45M | negative_65 stringlengths 13 5.47M | negative_66 stringlengths 13 79.7k | negative_67 stringlengths 14 1.45M | negative_68 stringlengths 13 1.45M | negative_69 stringlengths 14 5.47M | negative_70 stringlengths 14 326k | negative_71 stringlengths 14 1.89M | negative_72 stringlengths 13 1.45M | negative_73 stringlengths 14 5.47M | negative_74 stringlengths 9 143k | negative_75 stringlengths 9 1.89M | negative_76 stringlengths 11 309k | negative_77 stringlengths 11 309k | negative_78 stringlengths 14 1.89M | negative_79 stringlengths 13 4.07M | negative_80 stringlengths 9 1.89M | negative_81 stringlengths 11 155k | negative_82 stringlengths 9 1.45M | negative_83 stringlengths 11 4.07M | negative_84 stringlengths 15 309k | negative_85 stringlengths 14 1.45M | negative_86 stringlengths 14 309k | negative_87 stringlengths 14 309k | negative_88 stringlengths 13 1.45M | negative_89 stringlengths 14 5.47M | negative_90 stringlengths 11 114k | negative_91 stringlengths 13 54.6k | negative_92 stringlengths 13 155k | negative_93 stringlengths 14 326k | negative_94 stringlengths 14 95.2k | negative_95 stringlengths 9 110k | negative_96 stringlengths 14 230k | negative_97 stringlengths 13 304k | negative_98 stringlengths 9 79.7k | negative_99 stringlengths 14 1.45M | negative_scores listlengths 100 100 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
Str2Priority is used to convert a string to a priority. | func Str2Priority(val string) PriorityEnum {
val = strings.ToUpper(val)
switch val {
case "NO_PRIORITY":
return NoPriority
case "HIGH_PRIORITY":
return HighPriority
case "LOW_PRIORITY":
return LowPriority
case "DELAYED":
return DelayedPriority
default:
return NoPriority
}
} | func StringToPriority(str string) int {
switch str {
case "Critical":
return Critical
case "High":
return High
case "Medium":
return Medium
case "Low":
return Low
default:
return Low
}
} | func ToPriority(s string) (p Priority, ok bool) {
s = strings.ToUpper(s)
p, ok = prioName[s]
return
} | func FromString(level string) Priority {
level = strings.TrimSpace(strings.ToLower(level))
switch {
case level == "emergency":
return Emergency
case level == "alert":
return Alert
case level == "crtical":
return Critical
case level == "error":
return Error
case level == "warning":
return Warning
case ... | func GetEventPriorityFromString(val string) (EventPriority, error) {
switch val {
case string(EventPriorityNormal):
return EventPriorityNormal, nil
case string(EventPriorityLow):
return EventPriorityLow, nil
default:
return "", fmt.Errorf("Invalid event priority: '%s'", val)
}
} | func Priority(v string) predicate.WorkOrder {
return predicate.WorkOrder(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldPriority), v))
},
)
} | func (o WebAclRuleStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementSqliMatchStatementTextTransformation) int { return v.Priority }).(pulumi.IntOutput)
} | func makePriorityMap(str string) map[rune]int {
matchMap := make(map[rune]int)
for _, chr := range str {
matchMap[chr] += 1
}
return matchMap
} | func (o WebAclRuleStatementRegexMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementRegexMatchStatementTextTransformation) int { return v.Priority }).(pulumi.IntOutput)
} | func (o WebAclRuleStatementRateBasedStatementScopeDownStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementRateBasedStatementScopeDownStatementSqliMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func Str2Codec(str string) (byte, error) {
switch str {
case "raw-big":
return CodecRawBigEndian, nil
case "raw-little":
return CodecRawLittleEndian, nil
case "var":
return CodecVarInt, nil
case "rle":
return CodecRLE, nil
case "delta":
return CodecDelta, nil
case "delta-rle":
return CodecDeltaRLE, n... | func Str2Coder(str string) Coder {
str = strings.TrimSpace(str)
if str == "" {
return OK
}
i, err := strconv.Atoi(str)
if err != nil {
return ServerErr
}
return newCode(400, i, "")
} | func stringToLevel(str string) log4go.LevelType {
var level log4go.LevelType
str = strings.ToUpper(str)
switch str {
case "DEBUG":
level = log4go.DEBUG
case "TRACE":
level = log4go.TRACE
case "INFO":
level = log4go.INFO
case "WARNING":
level = log4go.WARNING
case "ERROR":
level = log4go.ERROR
case ... | func (me *Logger) SetPriorityString(s string) error {
s = strings.ToUpper(s)
for i, name := range priorityName {
if name == s {
me.SetPriority(i)
return nil
}
}
return fmt.Errorf("Unable to find priority %s", s)
} | func (o RuleGroupRuleStatementOrStatementStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementSqliMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementSqliMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o WebAclRuleStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementXssMatchStatementTextTransformation) int { return v.Priority }).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementSqliMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o WebAclRuleStatementRateBasedStatementScopeDownStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementRateBasedStatementScopeDownStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementSqliMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementSqliMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementRegexMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementRegexMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementRegexMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementRegexMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)... | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementRegexMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementRegexMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementByteMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementByteMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementByteMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementByteMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o WebAclRuleStatementRegexPatternSetReferenceStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementRegexPatternSetReferenceStatementTextTransformation) int { return v.Priority }).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementRegexMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementRegexMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)... | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func parseWeightAndPriority(s string) int {
r := strings.Split(s, ":")[1]
res, _ := strconv.Atoi(r)
return res
} | func (o RuleGroupRuleStatementOrStatementStatementByteMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementByteMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o WindowsVirtualMachineScaleSetOutput) Priority() pulumi.StringPtrOutput {
return o.ApplyT(func(v *WindowsVirtualMachineScaleSet) pulumi.StringPtrOutput { return v.Priority }).(pulumi.StringPtrOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementByteMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementByteMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementNotStatementStatementXssMatchStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementNotStatementStatementXssMatchStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (myTicket *Ticket) SetPriority(val string) {
myTicket.Priorityvar = &val
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementRegexPatternSetReferenceStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementRegexPatternSetReferenceStatementTextTransformation) int {
return v.Pri... | func (o RuleGroupRuleStatementOrStatementStatementRegexPatternSetReferenceStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementRegexPatternSetReferenceStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementRegexPatternSetReferenceStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementRegexPatternSetReferenceStatementTextTransformation) int {
return v.Prior... | func (m *Message) PriorityString() string {
return m.Facility() + "." + m.Severity()
} | func stringToLevel(input string) zerolog.Level {
switch strings.ToLower(input) {
case "none":
return zerolog.Disabled
case "trace":
return zerolog.TraceLevel
case "debug":
return zerolog.DebugLevel
case "warn", "warning":
return zerolog.WarnLevel
case "info", "information":
return zerolog.InfoLevel
cas... | func (s *server) parsePriority(buf []byte) error {
// The '<' character is ASCII 60 and MUST occur at the start of the
// message
if buf[0] != 60 {
return errors.New("priority is missing opening angle bracket)")
}
// The '>' character is ASCII 62 and MUST occur no more than 6 bytes from
// the start of the mes... | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementRegexPatternSetReferenceStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementRegexPatternSetReferenceStatementTextTransformation) int {
return v.Pri... | func StringToLevel(level string) Level {
switch l := strings.ToLower(level); l {
case "debug":
return DEBUG
case "info":
return INFO
case "warn":
return WARN
case "error":
return ERROR
case "fatal":
return FATAL
default:
return 0
}
} | func (o SchedulerRuleRuleOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v SchedulerRuleRule) *int { return v.Priority }).(pulumi.IntPtrOutput)
} | func StringToLevel(level string) Level {
switch level {
case "fatal":
return FatalLevel
case "error":
return ErrorLevel
case "warn", "warning":
return WarnLevel
case "debug":
return DebugLevel
case "info":
return InfoLevel
}
return InfoLevel
} | func (o RuleGroupRuleStatementOrStatementStatementOrStatementStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementOrStatementStatementSizeConstraintStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntO... | func (o RuleOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *Rule) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func (o WebAclRuleStatementRateBasedStatementScopeDownStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementRateBasedStatementScopeDownStatementSizeConstraintStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementAndStatementStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementAndStatementStatementSizeConstraintStatementTextTransformation) int {
return v.Priority
}).(pulumi.In... | func Str2Int(val string) int {
return int(wrapInt64Result(internalStr2Int(val, 0, false)))
} | func String2Int(s string) int {
out, err := strconv.Atoi(s)
if err != nil {
fmt.Printf("convert string '%s' to int error: %v", s, err)
}
return out
} | func (e *Event) SetPriority(v string) {
e.Priority = &v
} | func (n *Node) Priority(i SlotID, num int, nodeID NodeID) ([32]byte, error) {
m := new(bytes.Buffer)
m.WriteByte('P')
numBytes, _ := xdr.Marshal(num)
m.Write(numBytes)
m.WriteString(string(nodeID))
return n.G(i, m.Bytes())
} | func (o FirewallPolicyRuleOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *FirewallPolicyRule) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func (o *TasklistsIdTasksJsonTodoItem) SetPriority(v string) {
o.Priority = &v
} | func (o RouteOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *Route) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func stringToLevel(l string) (zerolog.Level, error) {
switch strings.ToLower(l) {
case "debug":
return zerolog.DebugLevel, nil
case "info":
return zerolog.InfoLevel, nil
case "warn", "warning":
return zerolog.WarnLevel, nil
case "error":
return zerolog.ErrorLevel, nil
case "fatal":
return zerolog.FatalL... | func (o WebAclRuleStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v WebAclRuleStatementSizeConstraintStatementTextTransformation) int { return v.Priority }).(pulumi.IntOutput)
} | func (o RuleGroupRuleStatementOrStatementStatementNotStatementStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementNotStatementStatementSizeConstraintStatementTextTransformation) int {
return v.Priority
}).(pulumi.In... | func (o RuleGroupRuleStatementOrStatementStatementSizeConstraintStatementTextTransformationOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RuleGroupRuleStatementOrStatementStatementSizeConstraintStatementTextTransformation) int {
return v.Priority
}).(pulumi.IntOutput)
} | func (o HttpRouteRuleResponseOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v HttpRouteRuleResponse) int { return v.Priority }).(pulumi.IntOutput)
} | func (o *ProjectsProjidTasksQuickaddJsonTodoItem) SetPriority(v string) {
o.Priority = &v
} | func StrToInt(str string) (value int, err error) {
value, err = strconv.Atoi(str)
return
} | func (o SecurityPolicyRuleOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v SecurityPolicyRule) *int { return v.Priority }).(pulumi.IntPtrOutput)
} | func (r *ListenerRule) Priority() pulumi.IntOutput {
return (pulumi.IntOutput)(r.s.State["priority"])
} | func StrToInt(s string) (int, error) {
return strconv.Atoi(s)
} | func StringToIntIfPossible(str string) interface{} {
intValue, err := strconv.Atoi(str)
if err == nil {
return intValue
} else {
return str
}
} | func ConvertStringToInt(in string) (result int) {
inLen := len(in) - 1
for i := 0; i <= inLen; i++ {
result += int(math.Pow(lenAlphabet+1, float64(i))) * (convertMapStringToInt[string(in[inLen-i])] + 1)
}
return
} | func (o TrafficMirrorFilterEgressRuleOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *TrafficMirrorFilterEgressRule) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func (q *IssueRequest) PriorityID(value string) {
q.values.Set("priorityId", value)
} | func (o HttpRouteRuleOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v HttpRouteRule) *int { return v.Priority }).(pulumi.IntPtrOutput)
} | func RcParsePriority(scanner *glib.Scanner, priority PathPriorityType) uint32 {
c_scanner := (*C.GScanner)(C.NULL)
if scanner != nil {
c_scanner = (*C.GScanner)(scanner.ToC())
}
c_priority := (C.GtkPathPriorityType)(priority)
retC := C.gtk_rc_parse_priority(c_scanner, &c_priority)
retGo := (uint32)(retC)
re... | func Strtoi(s string) int {
if i, err := strconv.Atoi(s); err != nil {
panic(errors.New("[argument error]: Strtoi only accepts integer string"))
} else {
return i
}
} | func Strtoi(s string) int {
if i, err := strconv.Atoi(s); err != nil {
panic(errors.New("[argument error]: Strtoi only accepts integer string"))
} else {
return i
}
} | func StrToInt(str string) int {
result, err := strconv.Atoi(str)
if err != nil {
LogToFile(fmt.Sprint(err))
}
return result
} | func (o FirewallPolicyRuleOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v FirewallPolicyRule) *int { return v.Priority }).(pulumi.IntPtrOutput)
} | func (o RoutingProfileQueueConfigOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v RoutingProfileQueueConfig) int { return v.Priority }).(pulumi.IntOutput)
} | func stringToInt(str string) (val int) {
val, err := strconv.Atoi(str)
check(err)
return val
} | func StringLevelToLevel(l string) uint32 {
switch l {
case "Debug":
return uint32(LDebug)
case "Info":
return uint32(LInfo)
case "Warning":
return uint32(LWarning)
case "Error":
return uint32(LError)
default:
panic("Invalid string level is within config files !")
}
} | func (o *MicrosoftGraphDomainDnsSrvRecord) SetPriority(v int32) {
o.Priority = &v
} | func (codec *Codec) UnicodeCollationPriority(
strength colltab.Level, alternate collate.AlternateHandling,
backwards, hiraganaQ, caseLevel, numeric bool) {
codec.strength = strength
codec.alternate = alternate
codec.backwards = backwards
codec.hiraganaQ = hiraganaQ
codec.caseLevel = caseLevel
codec.numeric = nu... | func (o FirewallPolicyRuleResponseOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v FirewallPolicyRuleResponse) int { return v.Priority }).(pulumi.IntOutput)
} | func StrToInt(iStr string) int {
i, err := strconv.Atoi(iStr)
if err != nil {
fmt.Println(err)
return 0
}
return i
} | func (o GetAccessRulesRuleOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v GetAccessRulesRule) int { return v.Priority }).(pulumi.IntOutput)
} | func (o RuleIdpDiscoveryOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v *RuleIdpDiscovery) pulumi.IntPtrOutput { return v.Priority }).(pulumi.IntPtrOutput)
} | func stringToInt(str string) int {
val, err := strconv.Atoi(str)
if err != nil {
panic(fmt.Sprint(err))
}
return val
} | func (o GetRoutingProfileQueueConfigOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v GetRoutingProfileQueueConfig) int { return v.Priority }).(pulumi.IntOutput)
} | func str2int(s string, def int) int {
s = strings.TrimSpace(s)
if s == "" {
return def
}
i, _ := strconv.Atoi(s)
return i
} | func (o FirewallRuleOutput) Priority() pulumi.IntPtrOutput {
return o.ApplyT(func(v *FirewallRule) pulumi.IntPtrOutput { return v.Priority }).(pulumi.IntPtrOutput)
} | func (*StrToIntConverter) Convert(kv *types.KeyValue) (*types.KeyValue, bool) {
if sv, ok := kv.Value.(string); ok {
s, err := strconv.Atoi(sv)
if err == nil {
return &types.KeyValue{Key: kv.Key, Value: s}, true
}
}
return nil, false
} | func (s *SchedItem) Priority() BuildletPriority {
switch {
case s.IsRelease:
return PriorityUrgent
case s.IsGomote:
return PriorityInteractive
case s.IsTry:
return PriorityAutomated
default:
return PriorityBatch
}
} | func Str2n(s string) (res int) {
fmt.Sscanf(s, "%d", &res)
return
} | func StrToInt(str string) int {
i, err := strconv.Atoi(str)
if err != nil {
fmt.Println(err.Error())
panic("Fail")
}
return i
} | func (o AccessRuleOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *AccessRule) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func strToInt(str string) (int, error) {
nonFractionalPart := strings.Split(str, ".")
return strconv.Atoi(nonFractionalPart[0])
} | func (o JobQueueOutput) Priority() pulumi.IntOutput {
return o.ApplyT(func(v *JobQueue) pulumi.IntOutput { return v.Priority }).(pulumi.IntOutput)
} | func ToClassification(s string) Classification {
return stringToClassification[s]
} | func NewPriority() *Filter {
return &Filter{Type: "priority", Config: Config{}}
} | func convertToInt(str string) int{
slotNum, err := strconv.Atoi(str);
if err != nil {
return -1
}
return slotNum
} | [
"0.82953197",
"0.72392666",
"0.6398675",
"0.5791403",
"0.5772629",
"0.576621",
"0.5755638",
"0.5697468",
"0.5684977",
"0.5646343",
"0.56061065",
"0.5605117",
"0.5572294",
"0.55379844",
"0.5531028",
"0.5522406",
"0.5517255",
"0.5490867",
"0.5461865",
"0.54358476",
"0.54330915"... |
UnmarshalJSON parses the config data to the DefaultConfig object. Because some parameters (OpenTime, ClosedDaysOfTheWeek, etc) have their original types and unmarshal methods but it's troublesome for other business logic to use those notgeneral types, so this method parses the data to an auxiliary struct and cast the t... | func (c *DefaultConfig) UnmarshalJSON(input []byte) error {
type Alias DefaultConfig
aux := &struct {
SymbolsUpdateTime CustomTime `json:"symbols_update_time"`
UpdateTime CustomTime `json:"update_time"`
OpenTime CustomTime `json:"openTime"` // deprecated
CloseTime CustomTi... | func Unmarshal(data []byte, v interface{}) error {
return ConfigDefault.Unmarshal(data, v)
} | func Unmarshal(schema Schema, data []byte, v any) error {
return DefaultConfig.Unmarshal(schema, data, v)
} | func (config *Config) UnmarshalJSON(body []byte) (err error) {
var configJSON struct {
Type string `json:"type"`
ID string `json:"id"`
Version uint64 `json:"ver"`
Data json.RawMessage `json:"data,omitempty"`
}
if err = json.Unmarshal(body, &configJSON); err != nil {
r... | func Unmarshal(data []byte, o interface{}) error {
return DefaultDecoderConfig.Unmarshal(data, o)
} | func (c *Config) UnmarshalJSON(data []byte) error {
type Alias Config
aux := &struct {
CacheHealthPollingIntervalMs *uint64 `json:"cache_health_polling_interval_ms"`
CacheStatPollingIntervalMs *uint64 `json:"cache_stat_polling_interval_ms"`
MonitorConfigPollingIntervalMs *uint64 `json:"monitor_config_poll... | func (daemonConfig *EventHarvestConfig) UnmarshalJSON(b []byte) error {
// Get the default report period in milliseconds.
reportPeriodMs, err := durationToMilliseconds(limits.DefaultReportPeriod)
if err != nil {
return err
}
// Build a new struct that represents what we'll get from the collector with
// the co... | func (b *BfdConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", b, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "administrativeState":
err = un... | func (c *Config) Unmarshal(data []byte) error {
err := json.Unmarshal(data, c)
if err != nil {
return err
}
return nil
} | func (d *DWCopyCommandDefaultValue) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "columnName":
err = un... | func (j *JSONFieldWithDefault) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", j, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "defaultValue":
err = unpop... | func Unmarshal(r io.Reader, v interface{}) (err error) {
// read the whole config to []byte.
var d *json.Decoder
d = json.NewDecoder(NewJsonPlusReader(r))
//d = json.NewDecoder(f)
if err = d.Decode(v); err != nil {
return
}
return
} | func (config *eventStateConfigJSON) UnmarshalJSON(
data []byte,
) (
err error,
) {
var item struct {
Type string `json:"type"`
}
err = json.Unmarshal(data, &item)
if err != nil {
return
}
switch item.Type {
case "literal":
var payload LiteralEventConfig
err = json.Unmarshal(data, &payload)
if err ... | func (m *TestConfiguration) UnmarshalJSON(raw []byte) error {
// AO0
var aO0 TestConfigurationCreateUpdateParameters
if err := swag.ReadJSON(raw, &aO0); err != nil {
return err
}
m.TestConfigurationCreateUpdateParameters = aO0
// now for regular properties
var propsTestConfiguration struct {
ID int32 `json:... | func unmarshal(cfg *Configuration, settings map[string]interface{}) error {
if interval, ok := settings["scrape_interval"]; ok {
intervalInSecs := interval.(int)
cfg.scrapeInterval = time.Duration(intervalInSecs * int(time.Second))
}
if mountPoint, ok := settings["mount_point"]; ok {
cfg.mountPoint = mountPoin... | func Parse(data string, format string) (c Config, err error) {
var raw map[string]interface{}
switch format {
case "json":
err = json.Unmarshal([]byte(data), &raw)
case "hcl":
err = hcl.Decode(&raw, data)
default:
err = fmt.Errorf("invalid format: %s", format)
}
if err != nil {
return Config{}, err
}
... | func (_m *GosoConf) UnmarshalDefaults(val interface{}, additionalDefaults ...cfg.UnmarshalDefaults) {
_va := make([]interface{}, len(additionalDefaults))
for _i := range additionalDefaults {
_va[_i] = additionalDefaults[_i]
}
var _ca []interface{}
_ca = append(_ca, val)
_ca = append(_ca, _va...)
_m.Called(_ca.... | func (c *config) UnmarshalJSON(data []byte) error {
type Alias config
aux := &struct {
Z string `json:"z"`
X string `json:"x"`
SI string `json:"si"`
*Alias
}{
Alias: (*Alias)(c),
}
if err := json.Unmarshal(data, &aux); err != nil {
return err
}
if aux.Data != nil {
err := checkData(aux.Data)
i... | func (d *Dynconfig) Unmarshal(rawVal interface{}, opts ...DecoderConfigOption) error {
return d.strategy.Unmarshal(rawVal, opts...)
} | func (o *SyntheticsTestOptionsMonitorOptions) UnmarshalJSON(bytes []byte) (err error) {
raw := map[string]interface{}{}
all := struct {
RenotifyInterval *int64 `json:"renotify_interval,omitempty"`
}{}
err = json.Unmarshal(bytes, &all)
if err != nil {
err = json.Unmarshal(bytes, &raw)
if err != nil {
retur... | func (conf *Config) UnmarshalJSON(bytes []byte) error {
type confAlias Config
aliased := confAlias(NewConfig())
defaultFields := aliased.StaticFields
aliased.StaticFields = nil
if err := json.Unmarshal(bytes, &aliased); err != nil {
return err
}
if aliased.StaticFields == nil {
aliased.StaticFields = defau... | func (m *EmailNotificationConfig) UnmarshalJSON(raw []byte) error {
var data struct {
// The template of the email notification.
//
// You can use the following placeholders:
// * `{ImpactedEntities}`: Details about the entities impacted by the problem in form of a JSON array.
// * `{ImpactedEntity}`: The ... | func (f *FactoryGitHubConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "accountName":
err = ... | func (l *Layer2Configuration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", l, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "interfaces":
err = unpopula... | func (c *Config) UnmarshalJSON(bytes []byte) error {
var baseConfig struct {
ID string
Type string
}
err := json.Unmarshal(bytes, &baseConfig)
if err != nil {
return err
}
if baseConfig.Type == "" {
return fmt.Errorf("missing required field 'type'")
}
builderFunc, ok := registry[baseConfig.Type]
i... | func (e *Config) UnmarshalJSON(data []byte) error {
tmp := ConfigCopy{}
err := json.Unmarshal(data, &tmp)
if err != nil {
return err
}
tmp2 := Config(tmp)
*e = tmp2
return nil
} | func (d *DeliveryConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "deliveryMode":
err = unpo... | func (f *FactoryGitHubConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "accountName":
err = unpopulate(val, &f.AccountName)
delete(ra... | func GetDefaultsJson() inc.DefaultConf {
hostname, _ := os.Hostname()
jsonBlob := []byte("{\"servername\":\"" + hostname + "\",\"proclife\":\"" + inc.PROC_LIFE + "\",\"sleep\":\"" +
inc.SLEEP + "\",\"sendport\":\"" + inc.SEND_PORT + "\",\"sendhosts\":\"" + inc.SEND_HOSTS + "\", " +
"\"evictinterval\":\"" + inc.EV... | func (x *PullGatewayConfigurationRequest) UnmarshalJSON(b []byte) error {
return jsonplugin.DefaultUnmarshalerConfig.Unmarshal(b, x)
} | func (r *ReportConfigTimePeriod) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", r, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "from":
err = unpopulateT... | func (d *DefaultRolloutStatus) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "completedRegions":
err = u... | func (a *ApplianceNetworkConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", a, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "macAddress":
err ... | func (v *EConf) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson5d27fa6dDecodeGithubComKingsgrouposArchivistLibGoOverwriteConf(&r, v)
return r.Error()
} | func (m *VictorOpsNotificationConfig) UnmarshalJSON(raw []byte) error {
var data struct {
// The API key for the target VictorOps account.
// Max Length: 1000
// Min Length: 1
APIKey string `json:"apiKey,omitempty"`
// The content of the message.
//
// You can use the following placeholders:
// * `{... | func UnmarshalConfig(config json.RawMessage, target interface{}) error {
if len(config) == 0 {
return nil
}
d := json.NewDecoder(bytes.NewReader(config))
d.DisallowUnknownFields()
return d.Decode(target)
} | func (c *CSharpFunctionRetrieveDefaultDefinitionParameters) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "bindingRetrievalProperties":
err = unpopu... | func (m *HostConfig) UnmarshalJSON(raw []byte) error {
// AO0
var dataAO0 struct {
AutoRemove bool `json:"AutoRemove,omitempty"`
Binds []string `json:"Binds"`
CapAdd []string `json:"CapAdd"`
CapDrop []string `json:"CapDrop"`
Cgroup string `json:"Cgroup,omitempty"`
ConsoleSize []*int64 `json:"ConsoleS... | func (a *AzureMachineLearningStudioFunctionRetrieveDefaultDefinitionParameters) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "bindingRetrievalProperti... | func (c *Config) Parse(data []byte) error {
var newData objx.Map
unmarshalErr := json.Unmarshal(data, &newData)
if unmarshalErr != nil {
return unmarshalErr
}
// merge the data
c.data = c.Data().Merge(newData)
// no errors
return nil
} | func Unmarshal(boot string, v interface{}) error {
file, err := ioutil.ReadFile(fmt.Sprintf("./config.%s.json", boot))
if err != nil {
return err
}
return json.Unmarshal(file, &v)
} | func (c *ConfigurationData) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", c, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "configurationIdentifier":
err... | func (d *DWCopyCommandSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "additionalOptions":
err =... | func loadConfigFromJSON(config *Config) {
path := configPath()
configFile, err := os.Open(path)
if err != nil {
panic(err)
}
decoder := json.NewDecoder(configFile)
err = decoder.Decode(config)
if err != nil {
panic(err)
}
if config.TimeoutScale == nil {
defaultTimeout := 1.0
config.TimeoutScale = &d... | func (l *Lxconfig) ParseJSON(pack []byte) error {
// aux := new(auxillaryconf)
err := json.Unmarshal(pack, l)
if err != nil {
return err
}
l.Freeze = useDefaultInt(l.Freeze, FREEZEMS)
l.ProfileDelay = useDefaultInt(l.ProfileDelay, PDELAY)
l.Dumpms = useDefaultInt(l.Dumpms, DUMPS)
l.Connms = useDefaultInt(l.... | func deferredConfigUnmarshal(raw util.RawYAML, ref interface{}) (Config, error) {
switch ref := ref.(type) {
case Config:
out := cloneValue(ref).(Config)
err := yaml.UnmarshalStrict(raw, out)
return out, err
case v1.Config:
var (
common common.MetricsConfig
out = cloneValue(ref).(v1.Config)
)
mu... | func (f *ForwardingConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "backendPool":
err = unp... | func TestFillStructRecursiveInitConfigAllDefaultNoValmap(t *testing.T) {
config := newConfiguration()
//init parsers
parsers := map[reflect.Type]Parser{
reflect.TypeOf([]ServerInfo{}): &sliceServerValue{},
}
var boolParser boolValue
parsers[reflect.TypeOf(true)] = &boolParser
var intParser intValue
parsers[r... | func (s *StagingSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "enableCompression":
err = unpopulate(val, &s.EnableCompression)
delete(r... | func (c *ThrottleConfig) UnmarshalJSON(b []byte) error {
var tc throttleConfigJSON
if err := json5.Unmarshal(b, &tc); err != nil {
return err
}
dur, err := human.ParseDuration(tc.TimeWindow)
if err != nil {
return err
}
c.AttemptCount = tc.AttemptCount
c.TimeWindow = dur
return nil
} | func DecodeConfig(r io.Reader) (*Config, error) {
var raw interface{}
dec := json.NewDecoder(r)
if err := dec.Decode(&raw); err != nil {
return nil, err
}
// Decode
var md mapstructure.Metadata
var result Config
msdec, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
Metadata: &md,
Result: ... | func (s *SelfHostedIntegrationRuntimeStatusTypeProperties) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "autoUpdate":
err = unpopulate(val, &s.Auto... | func configApplyDefault(config GwentConfig) *GwentConfig {
defaultConfig := NewGwentConfig()
setDefaultStruct := func(base, current interface{}) {
s2 := reflect.ValueOf(base).Elem()
s := reflect.ValueOf(current).Elem()
if s2.Type() != s.Type() {
panic("Underlying interface type doesn't match.")
}
for ... | func unmarshalJSON(data []byte, config interface{}, errorOnUnmatchedKeys bool) error {
reader := strings.NewReader(string(data))
decoder := json.NewDecoder(reader)
if errorOnUnmatchedKeys {
decoder.DisallowUnknownFields()
}
err := decoder.Decode(config)
if err != nil && err != io.EOF {
return err
}
return... | func (a *AzureBlobFSReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "deleteFilesAfterCompletion":
err = unpopulate(val, &a.DeleteFilesAf... | func Unmarshal(file string, schema interface{}) error {
data, err := ioutil.ReadFile(file)
if err != nil {
return err
}
ext := filepath.Ext(file)
// for collecting config keys
cfgs := make(Configs, 5)
switch ext {
case jsonExt:
err = json.Unmarshal(data, &cfgs)
if err != nil {
return errors.Wrap(err,... | func (i *IngressConfig) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", i, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "readTimeoutInSeconds":
err = unpo... | func (d *DelimitedTextReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "compressionProperties":
d.CompressionProperties, err = unmarshalC... | func (f *FunctionRetrieveDefaultDefinitionParameters) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
return f.unmarshalInternal(rawMsg)
} | func (v *HConf) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonA1edf190DecodeGithubComKingsgrouposArchivistLibGoOverwriteConf(&r, v)
return r.Error()
} | func TestFillStructRecursiveNoConfigAllDefaultSomeValmap(t *testing.T) {
config := &Configuration{}
//init parsers
parsers := map[reflect.Type]Parser{
reflect.TypeOf([]ServerInfo{}): &sliceServerValue{},
}
var boolParser boolValue
parsers[reflect.TypeOf(true)] = &boolParser
var intParser intValue
parsers[ref... | func (f *FiltersConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "filters":
f.Filters, err =... | func init() {
jsonFile, err := os.Open(configFile)
if err != nil {
log.Errorf("unable to open file %s", configFile)
// Use the default values for the configuration
Data = config{
BaseURL: defaultBaseURL,
}
return
}
defer jsonFile.Close()
byteValue, _ := ioutil.ReadAll(jsonFile)
json.Unmarshal(byteVal... | func (c *Config) UnmarshalYAML(unmarshal func(interface{}) error) error {
*c = DefaultConfig
// We want to set c to the defaults and then overwrite it with the input.
// To make unmarshal fill the plain data struct rather than calling UnmarshalYAML
// again, we have to hide it using a type indirection.
type plain ... | func (m *ModalConfig) UnmarshalJSON(data []byte) error {
x := struct {
Body *TypedObject `json:"body,omitempty"`
Form *Form `json:"form,omitempty"`
Opened bool `json:"opened"`
ModalSize ModalSize `json:"size,omitempty"`
Buttons []Button `json:"buttons,omitempty"`
Alert ... | func TestFillStructRecursiveNoConfigAllDefaultNoValmap(t *testing.T) {
config := &Configuration{}
//init parsers
parsers := map[reflect.Type]Parser{
reflect.TypeOf([]ServerInfo{}): &sliceServerValue{},
}
var boolParser boolValue
parsers[reflect.TypeOf(true)] = &boolParser
var intParser intValue
parsers[refle... | func (f *FormatReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "type":
err = unpopulate(val, &f.Type)
delete(rawMsg, key)
default:
... | func (v *NullableSharedDashboardUpdateRequestGlobalTime) UnmarshalJSON(src []byte) error {
v.isSet = true
// this object is nullable so check if the payload is null or empty string
if string(src) == "" || string(src) == "{}" {
return nil
}
return json.Unmarshal(src, &v.value)
} | func (d *DelimitedTextReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "compressionProperties":
... | func (f *FactoryRepoConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "accountName":
err = un... | func (t *TransferConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", t, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "transferAllDetails":
err ... | func (c *CustomSetupBase) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", c, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "type":
err = unpopulate(val, "T... | func (j *JavaScriptFunctionRetrieveDefaultDefinitionParameters) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "bindingRetrievalProperties":
err = un... | func (f *FormatReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "type":
err = unpopulate(val,... | func (conf *Config) Unmarshal(k string, v interface{}) error {
tmp := conf.MapString(k)
data, err := json.Marshal(tmp)
if err != nil {
return mise.WrapErrorMsg(err, fmt.Sprintf("config.Unmarshal(%s) => %#v", k, tmp))
}
err = json.Unmarshal(data, v)
if err != nil {
return mise.WrapErrorMsg(err, fmt.Sprintf("co... | func TestUnmarshal(t *testing.T) {
operatortest.ConfigUnmarshalTests{
DefaultConfig: NewConfig(),
TestsFile: filepath.Join(".", "testdata", "config.yaml"),
Tests: []operatortest.ConfigUnmarshalTest{
{
Name: "flatten_body_one_level",
Expect: func() *Config {
cfg := NewConfig()
cfg.Field =... | func (s *StagingSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", s, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "enableCompression":
err = unpop... | func (o *OracleCloudStorageReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "deleteFilesAfterCompletion":
err = unpopulate(val, &o.Delete... | func (s *SelfHostedIntegrationRuntimeStatusTypeProperties) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", s, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "a... | func Default(values interface{}) Config {
return &wrapper{
NewDecoder: decoders["json"],
AppName: path.Base(os.Args[0]),
Values: values,
}
} | func unWarpDefaultConfig() *types.Config {
c := *types.NewConfig()
conf := os.Getenv("OPS_DEFAULT_CONFIG")
if conf != "" {
data, err := ioutil.ReadFile(conf)
if err != nil {
fmt.Fprintf(os.Stderr, "error reading config: %v\n", err)
os.Exit(1)
}
err = json.Unmarshal(data, &c)
if err != nil {
fmt.Fp... | func (a *AzureMachineLearningServiceFunctionRetrieveDefaultDefinitionParameters) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "bindingRetrievalPropert... | func LoadConfigFromData(data []byte) (err error) {
err = json.Unmarshal(data, &configMap)
return
} | func (c *Config) UnmarshalJSON(data []byte) error {
return json.Unmarshal(data, &c.flags)
} | func (d *DashboardWidgetRawConfiguration) UnmarshalJSON(data []byte) error {
if d == nil {
return errors.New("entities.DashboardWidgetRawConfiguration: UnmarshalJSON on nil pointer")
}
*d = append((*d)[0:0], data...)
return nil
} | func (m *ThresholdMonitor) UnmarshalJSON(raw []byte) error {
// AO0
var aO0 ThresholdMonitorInput
if err := swag.ReadJSON(raw, &aO0); err != nil {
return err
}
m.ThresholdMonitorInput = aO0
// AO1
var dataAO1 struct {
CreatedAt strfmt.DateTime `json:"created_at,omitempty"`
UpdatedAt strfmt.DateTime `json... | func (o *MonitorThresholdWindowOptions) UnmarshalJSON(bytes []byte) (err error) {
raw := map[string]interface{}{}
all := struct {
RecoveryWindow NullableString `json:"recovery_window,omitempty"`
TriggerWindow NullableString `json:"trigger_window,omitempty"`
}{}
err = json.Unmarshal(bytes, &all)
if err != nil ... | func (c *MbaConfig) UnmarshalJSON(data []byte) error {
raw := new(interface{})
err := json.Unmarshal(data, raw)
if err != nil {
return err
}
conf := MbaConfig{}
switch (*raw).(type) {
case []interface{}:
helper := CacheIdMbaConfig{}
if err := json.Unmarshal(data, &helper); err != nil {
return err
}
... | func (c *Config) loadDefaults() {
if strings.TrimSpace(c.ModulePath) == "" {
c.ModulePath = defaultModulePath
}
if strings.TrimSpace(c.TLSServerCertPath) == "" {
c.TLSServerCertPath = defaultTLSServerCertPath
}
if strings.TrimSpace(c.TLSServerKeyPath) == "" {
c.TLSServerKeyPath = defaultTLSServerKeyPath
}
... | func (s *SelfHostedIntegrationRuntimeStatus) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "dataFactoryName":
err = unpopulate(val, &s.DataFactoryNa... | func (target *TimerEventConfig) UnmarshalJSON(
data []byte,
) (
err error,
) {
var source struct {
NextState string `json:"nextState"`
Interval float64 `json:"interval"`
}
err = json.Unmarshal(data, &source)
if err != nil {
return
}
*target = TimerEventConfig{
NextState: source.NextState,
Interval... | func (j *Config) UnmarshalJSON(input []byte) error {
fs := fflib.NewFFLexer(input)
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
} | func (f *FunctionConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "binding":
f.Binding, err = unmarshalFunctionBindingClassification(val... | func (f *FactoryVSTSConfiguration) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", f, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "accountName":
err = un... | func (us *UserSetting) UnmarshalJSON(data []byte) error {
type Alias UserSetting
userSetting := &struct{
LastUpdated string `json:"lastUpdated"`
*Alias
}{
Alias: (*Alias)(us),
}
var err error
if err = json.Unmarshal(data, &userSetting); err != nil {
return err
}
//special treatment for fields containing... | func (f *FtpReadSettings) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "deleteFilesAfterCompletion":
err = unpopulate(val, &f.DeleteFilesAfterCompl... | func (o *ODataSource) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "additionalColumns":
err = unpopulate(val, &o.AdditionalColumns)
delete(rawMs... | func (m *AlertChannelSlackParams) UnmarshalJSON(raw []byte) error {
var data struct {
// icon Url
// Required: true
IconURL *string `json:"iconUrl"`
// username
// Required: true
Username *string `json:"username"`
// webhook Url
// Required: true
WebhookURL *string `json:"webhookUrl"`
}
buf := b... | func (c *Configuration) UnmarshalJSON(data []byte) error {
var err error
// Alias our type so that we can unmarshal as usual
type conf Configuration
// Unmarshal our base configuration
err = json.Unmarshal(data, (*conf)(c))
if err != nil {
return err
}
configMap := make(map[string]*json.RawMessage)
err ... | func (wmdd *WindModuleDashboardData) UnmarshalJSON(data []byte) (err error) {
type OriginalUnmarshal WindModuleDashboardData
tmp := struct {
TimeUTC int64 `json:"time_utc"` // timestamp when data was measured
DateMaxWindStr int64 `json:"date_max_wind_str"` // max wind date
*OriginalUnmarshal
}{... | func (sc *SfcConfig) Unmarshal(buf []byte) error {
// check for the buffer length, we expect 6*32 bytes
if len(buf) != 192 {
return fmt.Errorf("expected 192 bytes, %d received", len(buf))
}
// copy the data
sc.MinValidatorStake.ToInt().SetBytes(buf[:32])
sc.MaxDelegatedRatio.ToInt().SetBytes(buf[32:64])
sc.Mi... | [
"0.63182175",
"0.60798794",
"0.5882239",
"0.5829213",
"0.58212006",
"0.5816292",
"0.58080316",
"0.5611775",
"0.5558663",
"0.55574906",
"0.5507864",
"0.54944205",
"0.5485019",
"0.5482529",
"0.5473168",
"0.54017305",
"0.5394878",
"0.53913075",
"0.5339714",
"0.53381354",
"0.5332... |
UnmarshalJSON parses a string for a day of the week. | func (wd *weekday) UnmarshalJSON(input []byte) error {
s := strings.Trim(string(input), "\"")
if d, ok := daysOfWeek[s]; ok {
*wd = weekday(d)
return nil
}
return errors.Errorf("invalid weekday '%s'", s)
} | func (w *InnoWeekday) UnmarshalJSON(b []byte) error {
var dow string
if err := json.Unmarshal(b, &dow); err != nil {
return err
}
*w = InnoWeekday(DayOfWeek[dow])
return nil
} | func (w *Week) UnmarshalJSON(b []byte) error {
switch s := string(b); s {
case `1`, `2`, `3`, `4`, `5`:
i, err := strconv.ParseInt(s, 10, 0)
if err != nil {
return err
}
*w = Week(i)
case `"Last"`:
*w = Week(Last)
default:
return fmt.Errorf("Week cannot unmarshal %s", b)
}
return nil
} | func (v *Day) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson9311120dDecodeGithubComAhmdaeyzMbcApi2(&r, v)
return r.Error()
} | func (cd *CustomDay) UnmarshalJSON(input []byte) error {
s := strings.Trim(string(input), "\"")
if s == "null" {
*cd = CustomDay(time.Time{})
return nil
}
t, err := time.Parse(cdLayout, s)
if err != nil {
return err
}
*cd = CustomDay(t)
return nil
} | func (w *Week) UnmarshalJSON(data []byte) error {
if data[0] != '"' || data[len(data)-1] != '"' {
return errors.New("unable to unmarshal json: string literal expected")
}
year, week, err := decodeISOWeekDate(data[1 : len(data)-1])
if err != nil {
return errors.Wrap(err, "unable to unmarshal json")
}
w.year... | func (v *Day) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjson9311120dDecodeGithubComAhmdaeyzMbcApi2(l, v)
} | func (d *DayTime) UnmarshalJSON(src []byte) error {
var seconds int
err := json.Unmarshal(src, &seconds)
if err != nil {
return err
}
data := computeBySeonds(seconds)
*d = *data
return nil
} | func (k *KubernetesMaintenancePolicyDay) UnmarshalJSON(data []byte) error {
var val string
if err := json.Unmarshal(data, &val); err != nil {
return err
}
parsed, err := KubernetesMaintenanceToDay(val)
if err != nil {
return err
}
*k = parsed
return nil
} | func (cd *ChDate) UnmarshalJSON(b []byte) (err error) {
s := strings.Trim(string(b), "\"")
if len(s) == 0 {
return
}
cd.Time, err = time.Parse("02\\/01\\/2006", s)
return
} | func (d *Date) UnmarshalJSON(data []byte) (err error) {
var s string
err = json.Unmarshal(data, &s)
if err != nil {
return err
}
layouts := []string{
"2006-01-02", "2006-01", "2006",
}
err = nil
var t time.Time
for _, layout := range layouts {
t, err = time.Parse(layout, s)
if err == nil {
*d = Dat... | func (d *DateTime) UnmarshalJSON(b []byte) error {
var (
str = string(b)
t time.Time
err error
)
if str != "null" {
tm := strings.Trim(string(b), `"`)
for _, layout := range dateTimeLayouts {
t, err = time.Parse(layout, tm)
if err == nil {
break
}
}
if err != nil {
return err
}
}
... | func (e *Entry) UnmarshalJSON(j []byte) error {
var rawStrings map[string]interface{}
err := json.Unmarshal(j, &rawStrings)
if err != nil {
return err
}
for k, v := range rawStrings {
switch v := fmt.Sprint(v); strings.ToLower(k) {
case "title":
e.Title = v
case "body":
e.Body = v
case "starred... | func (r *WeekDay) UnmarshalYAML(unmarshal func(v interface{}) error) error {
var s string
if err := unmarshal(&s); err != nil {
return fmt.Errorf("WeekDay should be a string")
}
v, ok := _WeekDayNameToValue[s]
if !ok {
return fmt.Errorf("invalid WeekDay %q", s)
}
*r = v
return nil
} | func dayFromString(s string) (time.Weekday, error) {
switch strings.ToLower(s) {
case "måndag":
return time.Monday, nil
case "tisdag":
return time.Tuesday, nil
case "onsdag":
return time.Wednesday, nil
case "torsdag":
return time.Thursday, nil
case "fredag":
return time.Friday, nil
case "lördag":
ret... | func (hours *Hours) UnmarshalJSON(data []byte) (err error){
// intermediary to avoid an infinite loop
i := map[string][][]string{}
s, err := strconv.Unquote(string(data))
err = json.Unmarshal([]byte(s), &i)
if err != nil {
return errors.New(fmt.Sprintf("Invalid hours in JSON: %s (%s)", string(data), err))
}
*h... | func (d *InnoDate) UnmarshalJSON(b []byte) error {
var s string
if err := json.Unmarshal(b, &s); err != nil {
return err
}
reg, err := regexp.Compile(`(\d{4})-(\d{2})-(\d{2})`)
if err != nil {
return err
}
result := reg.FindStringSubmatch(s)
d.Exist = true
d.Year, _ = strconv.Atoi(result[1])
d.Month, _ ... | func (d *Date) UnmarshalJSON(b []byte) (err error) {
s := strings.Trim(string(b), "\"")
if s == "null" {
d.Time = time.Time{}
return
}
d.Time, err = time.Parse(dtLayout, s)
return
} | func (d *Date) UnmarshalJSON(b []byte) error {
var value string
err := json.Unmarshal(b, &value)
if err != nil {
return err
}
t, err := time.ParseInLocation("2006-01-02", value, time.UTC)
if err != nil {
return err
}
*d = Date{t}
return nil
} | func (d *LocalDate) UnmarshalJSON(data []byte) error {
l := jlexer.Lexer{Data: data}
d.unmarshalEasyJSON(&l)
return l.Error()
} | func (t *Timeparser) UnmarshalJSON(raw []byte) error {
str := strings.Trim(string(raw), `"`)
v, err := time.Parse("2006-01-02 15:04:05 GMT", str)
if err != nil {
v, err = time.Parse(time.RFC3339, str)
}
if err != nil {
v, err = time.Parse(time.RFC3339Nano, str)
}
if err != nil {
return errors.New("Unkown d... | func (i *AdminUpdateFrequency) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return fmt.Errorf("AdminUpdateFrequency should be a string, got %s", data)
}
var err error
*i, err = AdminUpdateFrequencyString(s)
return err
} | func (j *JSONDate) UnmarshalJSON(b []byte) error {
if j == nil {
return nil
}
s := strings.Trim(string(b), "\"")
t, err := time.Parse("2006-01-02 15:04", s)
if err != nil {
return err
}
*j = JSONDate(t)
return nil
} | func (m *FXProcessingDate) UnmarshalJSON(b []byte) error {
return ((*strfmt.Date)(m)).UnmarshalJSON(b)
} | func (t *DateTime) UnmarshalJSON(data []byte) error {
str := string(data)
var err error
t.Time, err = time.Parse(`"2006-01-02T15:04:05-0700"`, str)
return err
} | func (v *MessagePartSticker) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson3645a78fDecodeGithubComBm0IcqBotApiEvent1(&r, v)
return r.Error()
} | func (t *JSONDateTime) UnmarshalJSON(b []byte) error {
s := string(b)
s = Stripchars(s, "\"")
// x, err := time.Parse("2006-01-02", s)
if len(s) == 0 {
*t = JSONDateTime(TIME0)
return nil
}
x, err := StringToDate(s)
if err != nil {
return err
}
if x.Before(earliestDate) {
x = earliestDate
}
*t = JSON... | func (s *Schedule) UnmarshalJSON(b []byte) error {
// alias technique to avoid infinite recursion
type Alias Schedule
var a Alias
if err := json.Unmarshal(b, &a); err != nil {
return err
}
var bb bytes.Buffer
if err := json.Compact(&bb, b); err != nil {
return err
}
rawMessage := bb.String()
dest := Sc... | func parseWeekdayValue(raw string) (c weekdayComponent, err error) {
v, ok := weekdaysValues[strings.ToLower(raw)]
if !ok {
return c, errors.New("invalid weekday")
}
c.From = v
return c, nil
} | func (d *Date) UnmarshalJSON(data []byte) error {
var aux string
err := json.Unmarshal(data, &aux)
if err != nil {
return fmt.Errorf("error unmarshaling date to string: %s", err)
}
t, err := time.Parse("2006-01-02", aux)
if err != nil {
return fmt.Errorf("error converting string to date: %s", err)
}
*d = Da... | func (st *StationTime) UnmarshalJSON(data []byte) error {
stringTime := string(data)
parsedTime, err := time.Parse("\"15:04\"", stringTime)
if err != nil {
return err
}
st.Time = parsedTime
return nil
} | func (v *EventBackgroundServiceEventReceived) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjsonC5a4559bDecodeGithubComChromedpCdprotoBackgroundservice5(l, v)
} | func (t *Date) UnmarshalJSON(b []byte) error {
// Ignore null, like in the main JSON package.
if string(b) == "null" {
return nil
}
ti, err := time.Parse("\"2006-01-02\"", string(b))
if err != nil {
return err
}
*t = Date(ti)
return nil
} | func (r *RecurrenceScheduleOccurrence) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "day":
err = unpopulate(val, &r.Day)
delete(rawMsg, key)
c... | func (v *WidgetTickEdge) UnmarshalJSON(src []byte) error {
var value string
err := json.Unmarshal(src, &value)
if err != nil {
return err
}
*v = WidgetTickEdge(value)
return nil
} | func (t *JSONDate) UnmarshalJSON(b []byte) error {
s := string(b)
s = Stripchars(s, "\"")
if len(s) == 0 {
*t = JSONDate(TIME0)
return nil
}
// x, err := time.Parse("2006-01-02", s)
x, err := StringToDate(s)
if err != nil {
return err
}
if x.Before(earliestDate) {
x = earliestDate
}
*t = JSONDate(x)
... | func (t *SimpleDate) UnmarshalJSON(data []byte) error {
if isNull(data) {
return nil
}
data = trimQuotes(data)
if len(data) == 0 {
return nil // as an excepption here, allow empty "" on simple dates, as the server would render it on a response.
}
dataStr := string(data)
tt, err := time.Parse(SimpleDateLay... | func (b *builtinDayNameSig) evalString(row chunk.Row) (string, bool, error) {
idx, isNull, err := b.evalIndex(row)
if isNull || err != nil {
return "", isNull, err
}
return types.WeekdayNames[idx], false, nil
} | func (d *Date) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return err
}
// Ignore null, like in the main JSON package.
if s == "null" {
d.Status = pgtype.Null
return nil
}
var layout string
var err error
if d != nil {
layout = d.layout
}
if layout... | func (v *EventBackgroundServiceEventReceived) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoBackgroundservice5(&r, v)
return r.Error()
} | func (t *DateTime) UnmarshalJSON(b []byte) error {
var s string
err := json.Unmarshal(b, &s)
if err != nil {
return err
}
tt, err := time.Parse(DateTimeFormat, s)
if err != nil {
return err
}
*t = DateTime(tt.UTC())
return nil
} | func (nd *NumericDate) UnmarshalJSON(data []byte) error {
i := int64(0)
if err := json.Unmarshal(data, &i); err != nil {
return err
}
if err := nd.Decode(i); err != nil {
return err
}
return nil
} | func (v *Event) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjsonC5a4559bDecodeGithubComChromedpCdprotoBackgroundservice6(&r, v)
return r.Error()
} | func (v *MessagePartForward) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson3645a78fDecodeGithubComBm0IcqBotApiEvent6(&r, v)
return r.Error()
} | func (r *RecurrenceScheduleOccurrence) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", r, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "day":
err = unpopu... | func (t *Time) UnmarshalJSON(b []byte) error {
r := jlexer.Lexer{Data: b}
t.UnmarshalEasyJSON(&r)
return r.Error()
} | func (ne *NullExcelDate) UnmarshalJSON(b []byte) error {
if len(b) == 4 && b[0] == 110 && b[1] == 117 && b[2] == 108 && b[3] == 108 {
ne.Valid = false
return nil
}
err := json.Unmarshal(b, &ne.Date)
ne.Valid = (err == nil)
return err
} | func (o ResourcePolicyWeeklyCycleDayOfWeekResponseOutput) Day() pulumi.StringOutput {
return o.ApplyT(func(v ResourcePolicyWeeklyCycleDayOfWeekResponse) string { return v.Day }).(pulumi.StringOutput)
} | func (d *Date) UnmarshalJSON(buf []byte) (err error) {
if buf[0] == '"' {
buf = buf[1:]
}
if buf[len(buf)-1] == '"' {
buf = buf[:len(buf)-1]
}
d.Time, err = time.Parse(DateFormat, string(buf))
return
} | func parseSchedule(val string) (time.Weekday, error) {
if len(val) < 3 {
return parseScheduleNumber(val)
}
if weekDayName, ok := daysOfWeek[strings.ToLower(val)]; ok {
return weekDayName, nil
}
// try parsing number again in case prefixed by zeros
weekDayInt, err := parseScheduleNumber(val)
if err != nil {
... | func (e *EventType) UnmarshalJSON(data []byte) (err error) {
if len(data) < 3 {
*e = EventTypeUnknown
return
}
switch string(data[1 : len(data)-1]) {
case "account_creation":
*e = EventTypeAccountCreation
case "account_login":
*e = EventTypeAccountLogin
case "purchase":
*e = EventTypePurchase
case "re... | func (t *Date) UnmarshalJSON(buf []byte) (err error) {
tt, err := time.Parse(dateFormat, strings.Trim(string(buf), `"`))
if err != nil {
return
}
t.Time = tt
return nil
} | func (v *Packetbeat) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson5a98ae00DecodeGithubComAthouneLepsiusLumberSql(&r, v)
return r.Error()
} | func (t *Time) UnmarshalJSON(b []byte) error {
strDate := string(b)
layouts := map[int]string{
21: `"2006-01-02T15:04:05"`,
23: `"2006-01-02T15:04:05.0"`,
24: `"2006-01-02T15:04:05.00"`,
25: `"2006-01-02T15:04:05.000"`,
}
if strDate == "null" || len(strDate) == 0 {
return nil
}
layout := layouts[len(str... | func (t *Time) UnmarshalJSON(b []byte) (err error) {
if b[0] == '"' && b[len(b)-1] == '"' {
b = b[1 : len(b)-1]
}
if string(b) == `null` {
*t = Time{}
return
}
t.Time, err = time.Parse(layout, string(b))
return
} | func (t *Time) UnmarshalJSON(data []byte) (err error) {
layouts, err := t.selectLayouts()
if err != nil {
return err
}
t.Time, err = parseTime(layouts, string(data[1:len(data)-1]))
return err
} | func (wmdd *WindModuleDashboardData) UnmarshalJSON(data []byte) (err error) {
type OriginalUnmarshal WindModuleDashboardData
tmp := struct {
TimeUTC int64 `json:"time_utc"` // timestamp when data was measured
DateMaxWindStr int64 `json:"date_max_wind_str"` // max wind date
*OriginalUnmarshal
}{... | func (t *JSONTime) UnmarshalJSON(data []byte) error {
ut, err := time.Parse("02 January 2006", string(data))
if err == nil {
*t = JSONTime{ut}
}
// I had some issues with sessions so I'm gonna pass around this error
*t = JSONTime{time.Now()}
return nil
} | func (v *MessagePart) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson3645a78fDecodeGithubComBm0IcqBotApiEvent8(&r, v)
return r.Error()
} | func (t *TimeOSM) UnmarshalJSON(b []byte) error {
tr := strings.Trim(string(b), "\"")
return t.processTimeOSM(tr)
} | func (jt *JSONRFC3339NoZTimezone) UnmarshalJSON(data []byte) error {
b := bytes.NewBuffer(data)
dec := json.NewDecoder(b)
var s string
if err := dec.Decode(&s); err != nil {
return err
}
if s == "" {
return nil
}
t, err := time.Parse(RFC3339NoZ, s)
if err != nil {
return err
}
*jt = JSONRFC3339NoZTimez... | func (entity *DateControl) Unmarshal(raw []byte) error {
return json.Unmarshal(raw, entity)
} | func (d *NullableDate) UnmarshalJSON(b []byte) error {
s := strings.Trim(string(b), "\"")
t, err := time.Parse(RFC3339DATE, s)
if err != nil {
*d = NullableDate{Time: t, Valid: false}
} else {
*d = NullableDate{Time: t, Valid: true}
}
return nil
} | func (r *Event) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return fmt.Errorf("Event should be a string, got %s", data)
}
v, ok := _EventNameToValue[s]
if !ok {
return fmt.Errorf("invalid Event %q", s)
}
*r = v
return nil
} | func (d *DateTime) UnmarshalJSON(b []byte) error {
// expects a string lke this: 1607462787637
// with the last for digits containing nanoseconds.
var s string
err := json.Unmarshal(b, &s)
if err != nil {
return err
}
t, err := time.Parse(time.RFC3339Nano, s)
if err != nil {
return err
}
dt := DateTime{t... | func (i *triggerSystem) UnmarshalJSON(data []byte) error {
var s string
if err := json.Unmarshal(data, &s); err != nil {
return fmt.Errorf("triggerSystem should be a string, got %s", data)
}
var err error
*i, err = triggerSystemString(s)
return err
} | func (t *JSONTimeDate) UnmarshalJSON(data []byte) ([]byte, error) {
formatted := fmt.Sprintf("\"%s\"", t.Format(InitDateTime))
return []byte(formatted), nil
} | func (v *MessagePartSticker) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjson3645a78fDecodeGithubComBm0IcqBotApiEvent1(l, v)
} | func (w InnoWeekday) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf("\"%s\"", RevDayOfWeek[time.Weekday(w)])), nil
} | func (m *MovePerHour) UnmarshalJSON(b []byte) error {
var s SValue
if err := s.UnmarshalJSON(b); err != nil {
return err
}
*m = MovePerHour(s)
return nil
} | func (v *MessagePartForward) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjson3645a78fDecodeGithubComBm0IcqBotApiEvent6(l, v)
} | func (v *Event) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjsonC5a4559bDecodeGithubComChromedpCdprotoBackgroundservice6(l, v)
} | func (dt *DateTime) UnmarshalJSON(data []byte) error {
var t string
err := json.Unmarshal(data, &t)
if err != nil {
return errors.New("Invalid Datetime")
}
rawTime, err := time.Parse(unmarshalDTLayout, t)
if err != nil {
return err
}
*dt = DateTime{rawTime}
return nil
} | func (v *CSWaWaExchange) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson87c59537DecodeZhuawawaMsg40(&r, v)
return r.Error()
} | func (j *JsonBirthDate) UnmarshalJSON(b []byte) error {
s := strings.Trim(string(b), "\"")
t, err := time.Parse("2006-01-02", s)
if err != nil {
return err
}
*j = JsonBirthDate(t)
return nil
} | func (v *Dummy) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson241b18dfDecodeGithubComGrafanaDevtoolsPkgGhevents12(&r, v)
return r.Error()
} | func (r *RuleType) UnmarshalJSON(b []byte) error {
// After byte conversion, things coming out of db as
// '"node"' and '"event"'.
result, err := NewRuleType(strings.Trim(string(b), "\""))
if err != nil {
return err
}
*r = result
return nil
} | func (e *EventTime) UnmarshalJSON(b []byte) (err error) {
e.Time, err = time.Parse("2006-01-02T15:04:05.999999999", strings.Trim(string(b[:]), "\"\\"))
return
} | func (d *DateWrapper) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return fmt.Errorf("unmarshalling type %T: %v", d, err)
}
for key, val := range rawMsg {
var err error
switch key {
case "field":
err = unpopulateDateType(va... | func (s *KeySeed) UnmarshalJSON(b []byte) error {
if len(b) < 1 {
return errors.New("wrong seed length")
}
if n, err := hex.Decode(s[:], b[1:len(b)-1]); err != nil {
return err
} else if n != len(s) {
return errors.New("wrong seed length")
}
return nil
} | func (d *Date) UnmarshalJSON(bytes []byte) error {
var inI interface{}
if err := json.Unmarshal(bytes, &inI); err != nil {
return err
}
var in string
switch v := inI.(type) {
case int64:
d.Time = time.Unix(v, 0).UTC()
return nil
case float64:
d.Time = time.Unix(int64(v), 0).UTC()
return nil
case stri... | func WeekDay() string {
return lookup(lang, "weekdays", true)
} | func (w *Week) UnmarshalText(data []byte) error {
year, week, err := decodeISOWeekDate(data)
if err != nil {
return errors.Wrap(err, "unable to unmarshal text")
}
w.year, w.week = year, week
return nil
} | func (v *Date) UnmarshalJSON(data []byte) error {
r := jlexer.Lexer{Data: data}
easyjson9311120dDecodeGithubComAhmdaeyzMbcApi3(&r, v)
return r.Error()
} | func BenchmarkParseWeekDay(b *testing.B) {
for n := 0; n < b.N; n++ {
_, _ = isodates.ParseWeekDayStart("2019-W04-3")
}
} | func (wq *WeightedQuery) UnmarshalJSON(bytes []byte) error {
wq.Weight = 1
if strErr := json.Unmarshal(bytes, &wq.Query); strErr == nil {
return strErr
}
if objErr := json.Unmarshal(bytes, &wq.WeightedQueryCore); objErr != nil {
return errors.New("failed to unmarshal hub-advisor-query as string or json object"... | func (ee *ErrorEvent) Unmarshal(payload string) error {
return json.Unmarshal([]byte(payload), ee)
} | func (m *ItemItemsItemWorkbookFunctionsNetworkDays_IntlPostRequestBody) GetWeekend()(iadcd81124412c61e647227ecfc4449d8bba17de0380ddda76f641a29edf2b242.Jsonable) {
val, err := m.GetBackingStore().Get("weekend")
if err != nil {
panic(err)
}
if val != nil {
return val.(iadcd81124412c61e6472... | func (wm *WindMeasures) UnmarshalJSON(data []byte) (err error) {
// Add tmp type
type OriginalUnmarshal WindMeasures
tmp := struct {
WindTimestamp int `json:"wind_timeutc"`
*OriginalUnmarshal
}{
OriginalUnmarshal: (*OriginalUnmarshal)(wm),
}
// Unmarshall into the tmp fields
if err = json.Unmarshal(data, &... | func (v *Packetbeat) UnmarshalEasyJSON(l *jlexer.Lexer) {
easyjson5a98ae00DecodeGithubComAthouneLepsiusLumberSql(l, v)
} | func (u *Unix) WeekDayString(n int64) string {
return u.Time(n).Weekday().String()
} | func (ft *FeeType) UnmarshalJSON(b []byte) error {
var j string
err := json.Unmarshal(b, &j)
if err != nil {
return err
}
*ft, err = FeeTypeFromString(j)
return err
} | func (pbe *PlayerBannedEvent) Unmarshal(payload string) error {
return json.Unmarshal([]byte(payload), pbe)
} | func (x *Test_Nested_XNestedNested_EEE) UnmarshalJSON(b []byte) error {
num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
if err != nil {
return err
}
*x = Test_Nested_XNestedNested_EEE(num)
return nil
} | func ParseWeekdayList(list string) (days [7]bool, err error) {
list = strings.ToUpper(list)
for _, c := range list {
d, ok := dayAbbreviations[c]
if !ok {
return [7]bool{}, fmt.Errorf("invalid weekday abbreviation (%c) in %q", c, list)
}
if days[d] {
return [7]bool{}, fmt.Errorf("repeated day (%v) in %q... | func (t *Topic) UnmarshalJSON(data []byte) error {
var hex string
json.Unmarshal(data, &hex)
return t.FromHex(hex)
} | func (r *DeleteL7RulesResponse) FromJsonString(s string) error {
return json.Unmarshal([]byte(s), &r)
} | func (r *RecurrenceSchedule) UnmarshalJSON(data []byte) error {
var rawMsg map[string]json.RawMessage
if err := json.Unmarshal(data, &rawMsg); err != nil {
return err
}
for key, val := range rawMsg {
var err error
switch key {
case "hours":
err = unpopulate(val, &r.Hours)
delete(rawMsg, key)
case "m... | func (v *BoardType) UnmarshalJSON(buf []byte) error {
var val string
if err := json.Unmarshal(buf, &val); err != nil {
return err
}
switch val {
case "SCRUM":
*v = 0
case "KANBAN":
*v = 1
case "OTHER":
*v = 2
}
return nil
} | func (u *Uts) UnmarshalJSON(b []byte) error {
timestampString := strings.Trim(string(b), "\"")
timestampInt, err := strconv.Atoi(timestampString)
if err != nil {
return err
}
u.Time = time.Unix(int64(timestampInt), 0)
return nil
} | func (this *SystemdJournalEntry) UnmarshalJSON(data []byte) error {
// use an alias to prevent recursion
type entryAlias SystemdJournalEntry
aux := (*entryAlias)(this)
if err := json.Unmarshal(data, &aux); err == nil {
this.Message = startsWithTimestamp.ReplaceAllString(this.Message, "")
return nil
} else if... | [
"0.7233931",
"0.68035144",
"0.6664375",
"0.64271617",
"0.6389871",
"0.60552514",
"0.59573275",
"0.58633584",
"0.56584793",
"0.564598",
"0.55318886",
"0.54781157",
"0.5445037",
"0.5438726",
"0.53581256",
"0.5331975",
"0.53302944",
"0.5274132",
"0.5254272",
"0.52389354",
"0.520... |
UserDetails retrieve user queue entry details | func UserDetails(clientInstance *client.AdabasAdmin, dbid int, param string, auth runtime.ClientAuthInfoWriter) error {
params := online.NewGetUserQueueDetailParams()
params.Dbid = float64(dbid)
qid, qerr := strconv.Atoi(param)
if qerr != nil {
return qerr
}
params.Queueid = float64(qid)
resp, err := clientIn... | func getUserDetail(req *http.Request) (ud *models.UserDetail) {
if req.ContentLength > 0 {
if err := json.NewDecoder(req.Body).Decode(&ud); err != nil {
log.Println("error trying to decode user detail ", err)
return ud
}
}
log.Printf("User details [%v]", ud)
return ud
} | func UserDetails(c *gin.Context) {
var users []User
id := c.Query("id")
c.JSON(200, gin.H{
"message": database.DB.Find(&users, id),
})
} | func UserDetails(s *discordgo.Session, userID string) (user *discordgo.User, err error) {
user, err = s.User(userID)
if err != nil {
fmt.Println("error:", err)
return nil, err
}
return
} | func GetUserDetails(c *fiber.Ctx) error {
/*
* We will get the user context
* We will get the user id from the request
* We will get the user details from the db
*/
ctx, ok := c.UserContext().Value(config.AppContextKey{}).(*config.AppContext)
if !ok {
return c.JSON(dto.Error(errors.New("context not found")... | func GetQueuedJobInfoByUserId(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
if r.Method != http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
var request QueueJobRequestBody
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 10... | func GetUserDetailsHandler(ctx *gin.Context) {
var request IntrospectionRequest
err := ctx.ShouldBind(&request)
if err != nil {
log.Error(fmt.Errorf("unable to parse request body: %v", err))
StandardHTTP.InvalidRequestBody(ctx)
return
}
log.Debug(fmt.Sprintf("retrieved body %... | func UserQueue(clientInstance *client.AdabasAdmin, dbid int, auth runtime.ClientAuthInfoWriter) error {
params := online.NewGetDatabaseUserQueueParams()
rfc3339 := true
params.Rfc3339 = &rfc3339
params.Dbid = float64(dbid)
resp, err := clientInstance.Online.GetDatabaseUserQueue(params, auth)
if err != nil {
sw... | func (c *Client) DetailsForUser(id string) User {
return c.users[id]
} | func (u *UserHandler) MeDetails(w http.ResponseWriter, r *http.Request) {
// Iz zahtebve pridobi podatke o Emailu uporabnika
email := getUserEmail(r)
usr, err := u.UserService.UserByEmail(email)
if err != nil {
respondWithError(w, http.StatusInternalServerError, err.Error())
return
}
respondWithJSON(w, http... | func (e Endpoints) UserDetails(ctx context.Context, token string) (*model.User, error) {
req := UserDetailsRequest{
Jwt: token,
}
resp, err := e.UserDetailsEndpoint(ctx, req)
if err != nil {
return nil, err
}
userDetailsResp := resp.(UserDetailsResponse)
return &model.User{
ID: userDetailsResp.I... | func IsUserInQueue(user *tgbotapi.User) bool {
GetCredentialsStorage()
for _, item := range storage.usersQueue {
if item == user.ID {
return true
}
}
return false
} | func (m *EnrollmentTroubleshootingEvent) GetUserId()(*string) {
val, err := m.GetBackingStore().Get("userId")
if err != nil {
panic(err)
}
if val != nil {
return val.(*string)
}
return nil
} | func getGivenDetail(req *http.Request) (d map[string]string) {
if req.ContentLength > 0 {
if err := json.NewDecoder(req.Body).Decode(&d); err != nil {
log.Println("error trying to decode user detail ", err)
return nil
}
}
return d
} | func (m *MobileAppTroubleshootingEvent) GetUserId()(*string) {
val, err := m.GetBackingStore().Get("userId")
if err != nil {
panic(err)
}
if val != nil {
return val.(*string)
}
return nil
} | func GetDetails(db persistance.Client, id string) (*models.User, error) {
return db.GetUser(&models.User{
ID: id,
})
} | func (c *UserClient) QueryQueue(u *User) *QueueItemQuery {
query := &QueueItemQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := u.ID
step := sqlgraph.NewStep(
sqlgraph.From(user.Table, user.FieldID, id),
sqlgraph.To(queueitem.Table, queueitem.FieldID),
... | func (u Users) GetUserDetail() []byte{
b,err := json.Marshal(u)
if err != nil{
fmt.Println(err)
}
return b
} | func userHandler(w http.ResponseWriter, r *http.Request) {
mail := r.Header.Get("X-Goog-Authenticated-User-Email")
id := r.Header.Get("X-Goog-Authenticated-User-ID")
fmt.Fprint(w, "ID: "+id+"\nmail: "+mail)
} | func (c *Client) GetUserDetails(userName, accountAlias string) (details User, err error) {
req := struct { AccountAlias, UserName string } { accountAlias, userName }
err = c.getResponse("/User/GetUserDetails/JSON", &req, &struct {
BaseResponse
UserDetails *User
} { UserDetails: &details })
return
} | func (*Qos_Hqos_HqosProfiles_HqosProfile_HqosUserQueues_HqosUserQueue) Descriptor() ([]byte, []int) {
return file_huaweiV8R10_qos_proto_rawDescGZIP(), []int{23, 0, 7, 0, 5, 0}
} | func (r *SessionsGetter) Get() (userId string, err error) {
q, err := r.Channel.QueueDeclare(
"", // name
false, // durable
false, // delete when unsused
true, // exclusive
false, // no-wait
nil, // arguments
)
err = r.Channel.QueueBind(
q.Name, // queue name
"plutus-sessions", // r... | func (r *Container) User(ctx context.Context) (string, error) {
q := r.q.Select("user")
var response string
q = q.Bind(&response)
return response, q.Execute(ctx, r.c)
} | func (p *platform) QueueNext(token string) (*models.User, error) {
res, err := p.Request(messages.New("queue:next", libs.JSONObject{
"token": token,
}), time.Second*20)
if err != nil {
return nil, err
}
user := store.Users.Get(token)
if user == nil {
return nil, errors.New("queue pick failed")
}
name, ... | func (authHandler authHandler) handleQueue() *Queue {
packet, err := authHandler.WaitForPacket()
if err != nil {
fmt.Println(err)
}
queue, err := NewQueue(packet)
if err != nil {
fmt.Println(err)
} else {
queue.LogQueuePosition()
}
return queue
} | func (_AplpacaFarm *AplpacaFarmSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Amount *big.Int
RewardDebt *big.Int
BonusDebt *big.Int
FundedBy common.Address
}, error) {
return _AplpacaFarm.Contract.UserInfo(&_AplpacaFarm.CallOpts, arg0, arg1)
} | func (m *RiskyUserHistoryItem) GetUserId()(*string) {
return m.userId
} | func (s *SmartContract) getUserInfo(APIstub shim.ChaincodeStubInterface) (string,error) {
//Get the global ID by combining the local MSP userID with the mspID
userID, err := cid.GetID(APIstub)
if err != nil {
return "Error getting MSP specific user id: ", err
}
mspID, err := cid.GetMSPID(APIstub)
if err... | func (s *BaseSession) User() string { return s.user } | func (_AplpacaFarm *AplpacaFarmCallerSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Amount *big.Int
RewardDebt *big.Int
BonusDebt *big.Int
FundedBy common.Address
}, error) {
return _AplpacaFarm.Contract.UserInfo(&_AplpacaFarm.CallOpts, arg0, arg1)
} | func (r *ginRequest) User() *model.User {
return r.user
} | func getPostUser(c echo.Context) *User {
// リクエストボディをパースして代入
un, prof, items := c.FormValue("name"), c.FormValue("profile"), c.FormValue("items")
return &User{
UserName: un,
Profile: prof,
Items: items,
CreatedAt: time.Now(),
}
} | func (m *EndUserNotification) GetDetails()([]EndUserNotificationDetailable) {
val, err := m.GetBackingStore().Get("details")
if err != nil {
panic(err)
}
if val != nil {
return val.([]EndUserNotificationDetailable)
}
return nil
} | func GetJobInfoByUserId(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json; charset=UTF-8")
if r.Method != http.MethodPost {
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
var request QueueJobRequestBody
body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576)... | func RemoveUserFromQueue(user *tgbotapi.User) {
GetCredentialsStorage()
for i, item := range storage.usersQueue {
if item == user.ID {
storage.usersQueue = append(storage.usersQueue[:i], storage.usersQueue[i+1:]...)
}
}
} | func (p *platform) QueuePick(id, token string) (*models.User, error) {
res, err := p.Request(messages.New("queue:pick", libs.JSONObject{
"id": id,
"token": token,
}), time.Second*20)
if err != nil {
return nil, err
}
user := store.Users.Get(token)
if user == nil {
return nil, errors.New("queue pick f... | func AddUserToQueue(user *tgbotapi.User) {
GetCredentialsStorage()
storage.usersQueue = append(storage.usersQueue, user.ID)
} | func (h *handlerUser) GetUserDetail(w http.ResponseWriter, r *http.Request) {
//for tracking time execution
startTime := time.Now()
// get param request
vars := mux.Vars(r)
idStr := vars["id"]
id, err := strconv.ParseInt(idStr, 10, 64)
if err != nil {
log.Println(err)
return
}
// This is the option when... | func (_AplpacaFarm *AplpacaFarmCaller) UserInfo(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (struct {
Amount *big.Int
RewardDebt *big.Int
BonusDebt *big.Int
FundedBy common.Address
}, error) {
var out []interface{}
err := _AplpacaFarm.contract.Call(opts, &out, "userInfo", arg0, arg1)
outstru... | func (db *DB) getUserInfo(username string) *User {
var u User
err := db.authdb.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(userInfoBucketName)).Bucket([]byte(username))
if b == nil {
return errUserDoesNotExist
}
v := b.Get([]byte("role"))
u.Role = string(v)
u.Name = username
return nil
})... | func (b *BasicAuth) User() string {
return b.user
} | func (self *Client) QueueInfo() (*Reply, error) {
return self.call("S.QueueInfo", "", "")
} | func (m *TimeOff) GetUserId()(*string) {
val, err := m.GetBackingStore().Get("userId")
if err != nil {
panic(err)
}
if val != nil {
return val.(*string)
}
return nil
} | func (store Manager) GetUser(context User, userName string) (User, error) {
// Our return item
retval := User{}
err := store.systemdb.View(func(txn *badger.Txn) error {
item, err := txn.Get(GetKey("User", userName))
if err != nil {
return err
}
val, err := item.Value()
if err != nil {
return err
}... | func (ctx *BezuncAPIContext) User() models.User {
return ctx.Get("user").(models.User)
} | func GetUserDetail(c *gin.Context){
name := c.Param("name")
for _ , value := range Users{
// This will return if the user is found in our DB
if strings.ToLower(value.Name) == strings.ToLower(name){
c.JSON(200 , value)
return
}
}
// If user is not found we will return 404 with message
c.JSON(404, gin.... | func (o *SnmpTrapAllOf) GetUser() string {
if o == nil || o.User == nil {
var ret string
return ret
}
return *o.User
} | func (m *AlertHistoryState) GetUser()(*string) {
return m.user
} | func (*Qos_Hqos_HqosIFUserQueues_HqosIFUserQueue_HqosIFUserQueueStats_HqosIFUserQueueStat) Descriptor() ([]byte, []int) {
return file_huaweiV8R10_qos_proto_rawDescGZIP(), []int{23, 0, 3, 0, 0, 0}
} | func (_SwapMining *SwapMiningSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Quantity *big.Int
BlockNumber *big.Int
}, error) {
return _SwapMining.Contract.UserInfo(&_SwapMining.CallOpts, arg0, arg1)
} | func (_SwapMining *SwapMiningCallerSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Quantity *big.Int
BlockNumber *big.Int
}, error) {
return _SwapMining.Contract.UserInfo(&_SwapMining.CallOpts, arg0, arg1)
} | func Get_user_details(username string) User_details {
revel.TRACE.Printf("Get_user_details(): %s", username)
sr := QueryLdap(ldap_user_base, strings.Replace(ldap_user_filter, "*", username, -1), []string{ldap_user_uid_attr, ldap_user_cn_attr, ldap_user_photo_attr, ldap_user_group_attr})
// We expect exactl... | func (_PancakeFarm *PancakeFarmSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Amount *big.Int
RewardDebt *big.Int
}, error) {
return _PancakeFarm.Contract.UserInfo(&_PancakeFarm.CallOpts, arg0, arg1)
} | func (rURW RealUserReadWriter) GetDetails(i interface{}) useCases.User {
rwU := RWUser{}
switch v := i.(type) {
case int:
rwU = rURW.getUserByID(v)
case string:
rwU = rURW.getUserByName(v)
case Age:
rwU = rURW.getUserByAge(v)
default:
}
rURW.ucUser = rwU.UsecaseUser
return rURW.ToUseCaseUser()
} | func User(username string) *url.Userinfo | func GetDetailUser(c echo.Context) error {
objID, err := primitive.ObjectIDFromHex(c.Param("id"))
if err != nil {
return err
}
user, err := repository.GetDetailUser(objID)
if err != nil {
return err
}
return c.JSON(http.StatusOK, user)
} | func getUserInfo(userID int) (User, error) {
if userID > len(userList) {
return User{}, fmt.Errorf("not an valid id %v", userID)
}
return userList[userID-1], nil
} | func (b *backend) ProcessUserDetails(ud *v1.UserDetails, isCurrentUser bool, isAdmin bool) (*v1.UserDetailsReply, error) {
// Fetch the database user.
user, err := b.getUserByIDStr(ud.UserID)
if err != nil {
return nil, err
}
// Convert the database user into a proper response.
var udr v1.UserDetailsReply
www... | func getUser(req *http.Request) ClientUser {
// Maybe we want to check this user isn't empty, eventually.
return ClientUser{
Name: req.Header.Get("Sous-User-Name"),
Email: req.Header.Get("Sous-User-Email"),
}
} | func (s *ImmuServer) getUser(ctx context.Context, username []byte) (*auth.User, error) {
key := make([]byte, 1+len(username))
key[0] = KeyPrefixUser
copy(key[1:], username)
item, err := s.sysDB.Get(ctx, &schema.KeyRequest{Key: key})
if err != nil {
return nil, err
}
var usr auth.User
err = json.Unmarshal(i... | func (*Qos_QosCbQos_QosBehaviors_QosBehavior_QosActUserQueues_QosActUserQueue) Descriptor() ([]byte, []int) {
return file_huaweiV8R10_qos_proto_rawDescGZIP(), []int{23, 5, 0, 0, 23, 0}
} | func (_PancakeFarm *PancakeFarmCallerSession) UserInfo(arg0 *big.Int, arg1 common.Address) (struct {
Amount *big.Int
RewardDebt *big.Int
}, error) {
return _PancakeFarm.Contract.UserInfo(&_PancakeFarm.CallOpts, arg0, arg1)
} | func (a *adapter) GetUser(ctx *routing.Context) error {
claims := ctx.Get(ctxClaims).(*domain.AccessTokenClaims)
user, err := a.service.GetUser(claims.UserID)
if err != nil {
a.logger.Error("Error getting the logged in user!",
zap.Any("claims", claims),
zap.Error(err))
return err
}
return ctx.WriteData... | func (db *userDBstruct) GetDetailsByID(userID int64) (*userpb.User, error) {
details := &userpb.User{}
stmt, err := Client.Prepare(getUserDetailsByID)
if err != nil {
log.Println("Unable to prepare the getDetialsByID statement", err)
return nil, errors.New("unable to fetch the user details by the given id")
}
... | func getUserRoleAndBu(db *db.DB, userId int) (*models.UserInfo, error) {
userinfo := &models.UserInfo{}
if err := db.Grm.Debug().
Raw(`SELECT user.user_id, role.user_role_id, bu.bu_id
FROM user, user_has_user_role AS role, user_has_bu AS bu
WHERE user.user_id=role.user_id
AND user.user_id=bu.user_id
A... | func HandleCurrentUser(res http.ResponseWriter, req *http.Request) {
if user := req.Context().Value(currentuser.Key); user != nil {
fmt.Println("this is user ", user)
data, _ := json.Marshal(user)
fmt.Fprintf(res, string(data))
} else {
fmt.Println("Key not found: ", currentuser.Key)
}
} | func extractUserInfo(r *http.Request) *userInfo {
user, ok := r.Context().Value(ctxKeyUserInfo).(*userInfo)
if !ok {
log.Errorf("no auth info retrieved from client")
return &userInfo{}
}
return user
} | func (n *Network) GetUser(screenNameOrID interface{}) *User {
var u *User
v := url.Values{}
n.addscreenNameOrID(&v, screenNameOrID)
data, err := n.k.Get("users/show", v)
if err != nil {
log.Fatal(err)
}
json.Unmarshal(data, &u)
var blob json.RawMessage
err = json.Unmarshal(data, &blob)
if err != nil {
l... | func getCartInfo(stub shim.ChaincodeStubInterface, userID string) pb.Response {
var userDetail User
userInfoAsBytes, err := stub.GetState(userID)
if err != nil {
shim.Error(GetStateErrorMessage)
}
//Unmarshalling user json string to native go structure
err = json.Unmarshal(userInfoAsBytes, &userDetail)
if er... | func (ch *Chain) User() string {
return ch.user
} | func (o *ProcessSummaryAttributes) GetUser() string {
if o == nil || o.User == nil {
var ret string
return ret
}
return *o.User
} | func (a *UserDetails) GetID() string { return a.IdentityID } | func getUser(dsum *DataStoreUserManager, w http.ResponseWriter, r *http.Request) {
id := r.URL.Path[len("/user/"):]
u, e := dsum.Get(id)
returnJSON(errorOrData(u, e), w)
} | func GetUser(ctx context.Context) string {
_, claims, err := jwtauth.FromContext(ctx)
if err != nil {
return ""
}
user, ok := claims["user_id"].(string)
if user == "" || !ok {
return ""
}
return user
} | func (h *Handler) User(resp *http.Response, err error) {
check(err)
readBody(resp)
} | func resourceUserRead(d *schema.ResourceData, m interface{}) error {
config := m.(*Config)
user, _, err := getUserByKey(config.jiraClient, d.Id())
if err != nil {
return errors.Wrap(err, "getting jira user failed")
}
d.Set("name", user.Name)
d.Set("display_name", user.DisplayName)
d.Set("email", user.EmailAd... | func (*Qos_Hqos_HqosIFUserQueues_HqosIFUserQueue) Descriptor() ([]byte, []int) {
return file_huaweiV8R10_qos_proto_rawDescGZIP(), []int{23, 0, 3, 0}
} | func GetUser(ctx context.Context) (user interface{}) {
if ctx != nil {
user = ctx.Value(UserKey)
}
return
} | func User() string {
return user
} | func getUser(r *http.Request) (*User, error) {
if r.Body == nil {
return nil, errEmptyRequest
}
u := &User{}
err := json.NewDecoder(r.Body).Decode(u)
if err != nil {
return nil, err
}
return u, nil
} | func (e *User) QueryUserByID(ctx context.Context, req *user.QueryRequest, rsp *user.QueryResponse) error {
userID := req.UserId
if userID == "" {
userID = "xxxxxx"
}
userInfo := &user.UserInfo{
UserId: userID,
Nickname: "匿名",
Mobile: "138********",
AvatarUrl:... | func (r *DummyRequest) User() *model.User {
return r.user
} | func GetUser(request events.APIGatewayProxyRequest, db *gorm.DB) (events.APIGatewayProxyResponse, error) {
fmt.Println("Retrieving all Comments by User")
fmt.Println(request.QueryStringParameters["sub"])
sub := request.QueryStringParameters["sub"]
var comments []comments.Comment
db.Where("author_id = ?", sub).Fin... | func (q *Queue) Info() (*QueueInfo, error) {
size, err := Mongo.Count("message", bson.M{"project": q.ProjectID, "queue": q.ID})
if (err != nil) {
return nil, err
}
project := new(Project)
err = Mongo.GetId("project", q.ProjectID, &project)
if (err != nil) {
return nil, err
}
return &QueueInfo{Na... | func GetAuthenticatedUserFromContext(c *gin.Context) (string, error) {
claims := jwt.ExtractClaims(c)
id, ok := claims["id"]
if !ok {
return "", errors.New("failed to extract claim id")
}
strID, ok := id.(string)
if !ok {
return "", errors.New("failed to parse claim id")
}
if strID == "" {
return "", erro... | func (h *Handler) getUser(c *gin.Context) {
var input player.User
if err := c.ShouldBindJSON(&input); err != nil {
logrus.WithField("handler", "getUser").Errorf("error: %s", err.Error())
c.JSON(http.StatusBadRequest, errorResponse{
Error: err.Error(),
})
return
}
user, statistic, err := h.cache.Get(inpu... | func (r *Request) UserID() string {
return r.payload.User.UserID
} | func getQueueAttribute(sess *session.Session, queue queuingv1alpha1.Sqs, attributeName string) (string, error) {
svc := sqs.New(sess)
//log.Info("Getting queue attribute", "attribute", attributeName)
input := &sqs.GetQueueAttributesInput{
QueueUrl: &queue.Status.URL,
AttributeNames: []*string{
aws.String(attr... | func (m *MailboxEvidence) GetUserAccount()(UserAccountable) {
val, err := m.GetBackingStore().Get("userAccount")
if err != nil {
panic(err)
}
if val != nil {
return val.(UserAccountable)
}
return nil
} | func (c *client) QueueInfo() (*Info, error) {
out := new(Info)
uri := fmt.Sprintf(pathQueue+"/info", c.addr)
err := c.get(uri, out)
return out, err
} | func retrieveUser(key string ,req *http.Request)(User,error){
// ===============================================
// Grab our data from memcache
// ===============================================
data, err := retrieveFromMemcache(key, req)
if err != nil{
// =====================================
// Failing that ... | func FetchUserDetailsFromID(userID string) (string, string, error) {
fn := "FetchUserDetailsFromID"
// First fetch all users to get the client id for the client
headers, err := GetCommonHTTPHeaders(PxCentralAdminUser, PxCentralAdminPwd)
if err != nil {
log.Errorf("%s: %v", fn, err)
return "", "", err
}
var u... | func (_SwapMining *SwapMiningCaller) UserInfo(opts *bind.CallOpts, arg0 *big.Int, arg1 common.Address) (struct {
Quantity *big.Int
BlockNumber *big.Int
}, error) {
var out []interface{}
err := _SwapMining.contract.Call(opts, &out, "userInfo", arg0, arg1)
outstruct := new(struct {
Quantity *big.Int
Block... | func GetUser(c echo.Context, db *gorm.DB) (models.User, error) {
// get user from JWT
jwtContext := c.Get("user").(*jwt.Token)
claims := jwtContext.Claims.(jwt.MapClaims)
// get auth0 id from claims
id := claims["sub"].(string)
user := models.User{}
// find user in database
if (db.Where("auth_id = ?", i... | func getUserInfo(req *gopress.Request) interface{} {
return User{
Username: "mxzinke",
Repository: "gopress",
}
} | func (d DummyToken) UserInfo() (ThirdPartyUser, error) {
return d.info, nil
} | func (*Qos_Hqos_HqosProfiles_HqosProfile_HqosUserQueues) Descriptor() ([]byte, []int) {
return file_huaweiV8R10_qos_proto_rawDescGZIP(), []int{23, 0, 7, 0, 5}
} | func (h *userHandler) getUser(c echo.Context) error {
var (
userModel models.User
)
id := c.Param("id")
userID, _ := strconv.Atoi(id)
user, err := userModel.GetUserByID(uint(userID))
if err != nil {
return c.JSON(http.StatusInternalServerError, session.InternalServerError(c, err))
}
//show user
return... | func GetUserInfo(ctx context.Context) (UserInfo, error) {
userInfo, ok := ctx.Value(userInfoKey).(userInfo)
if !ok {
return nil, errors.New("Invalid user ID")
}
return userInfo, nil
} | func GetUser(c *gin.Context) {
IndentedJSON(c, 200, session.User(c))
} | func (service *Service) User(ID portainer.UserID) (*portainer.User, error) {
var user portainer.User
identifier := internal.Itob(int(ID))
err := internal.GetObject(service.db, BucketName, identifier, &user)
if err != nil {
return nil, err
}
return &user, nil
} | [
"0.6232837",
"0.61744744",
"0.60425085",
"0.59084624",
"0.5875294",
"0.58499056",
"0.5736718",
"0.559341",
"0.54441416",
"0.54340196",
"0.54268813",
"0.5375693",
"0.5368159",
"0.53537256",
"0.5293757",
"0.52802",
"0.52791435",
"0.52790385",
"0.5268659",
"0.5261966",
"0.525593... |
CommandQueue display all command queue entries | func CommandQueue(clientInstance *client.AdabasAdmin, dbid int, auth runtime.ClientAuthInfoWriter) error {
params := online.NewGetDatabaseCommandQueueParams()
rfc3339 := true
params.Rfc3339 = &rfc3339
params.Dbid = float64(dbid)
resp, err := clientInstance.Online.GetDatabaseCommandQueue(params, auth)
if err != ni... | func DisplayQueue(ret []Command) {
w := tabwriter.NewWriter(os.Stdout, 2, 2, 4, ' ', 0)
defer w.Flush()
show := func(a, b, c, d interface{}) {
fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", a, b, c, d)
}
show("HASH", "COMMAND", "DESCRIPTION", "STATUS")
for _, c := range ret {
cmdHash := c.CmdHash[0:15]
var cmdStri... | func (S *Sakamoto) displayQueue(args []string) {
err := S.getVoiceConn()
if err != nil {
log.Println(err.Error())
return
}
message, total := S.getInfoForEmbed()
// Setup Pagination for a long song queue
pageIndexs := [][2]int{}
totalMessageLen, currentPageLen, lastPage, lastID := 0, 0, 0, 0
for id, value... | func (hs *HotStuff) CommandQueue() CommandQueue {
return hs.commandQueue
} | func (a *App) QueueCmd() []Command {
cmds := a.CommandScheduler.QueuedCommands
a.DmnLogFile.Log.Println("Total queued: " + strconv.Itoa(len(cmds)))
return cmds
} | func (q *Queue) Display() {
elem := q.queue.Front()
for elem != nil {
fmt.Println(elem.Value)
elem = elem.Next()
}
} | func (q *Queue) Display() {
node := q.Head.Right
fmt.Printf("%d - [", q.Length)
for i := 0; i < q.Length; i++ {
fmt.Printf("{%s}", node.Value)
if i < q.Length-1 {
fmt.Printf("<-->")
}
node = node.Right
}
fmt.Println("]")
} | func (q *Q) Display() {
if incrementer <= 0 {
fmt.Println(ErrQueueIsEmpty)
} else {
fmt.Println(incrementer)
q.container.Display()
}
} | func (app *Application) Queue(command cmd.Command) {
err := app.projectService.ModifyModWith(func(modder world.Modder) error {
return app.cmdStack.Perform(command, modder)
})
if err != nil {
app.onFailure("command", "", err)
}
} | func getQueue(queue []int){
if len(queue) == 0 {
fmt.Println()
fmt.Println("Ready Queue: Currently empty.")
fmt.Println()
}else{
fmt.Printf(" -")
for i:= 0; i < len(queue); i++{
fmt.Printf("-----")
}
fmt.Printf("\nReady Queue: |")
for i := 0; i < len(queue); i++{
fmt.Printf(" P%d... | func (d *Dict) PushQueue(cmd DictCmd) {
d.Cmds <- cmd
} | func (c *Cache) Display() {
c.Queue.Display()
} | func (w *Client) ViewRequestQueue() (output [][]byte, err error) {
var (
temp []byte
errorCount int
)
for name := range w.requestQueue {
for i := range w.requestQueue[name] {
temp, err = json.Marshal(w.requestQueue[name][i])
if err != nil {
fmt.Println(err)
errorCount++
if errorCount >... | func (q *Queue) Print() {
for _, item := range q.elems {
fmt.Printf("%v ", item)
}
fmt.Println()
} | func (q Queue) Print() {
fmt.Println(q.que)
} | func (t *Tree) DisplayCommands(w io.Writer) {
maxNameLen := 0
for _, c := range t.Commands {
if len(c.Name) > maxNameLen {
maxNameLen = len(c.Name)
}
}
fmt.Fprintf(w, "%s commands:\n", t.Title)
for _, c := range t.Commands {
if c.Brief != "" {
fmt.Fprintf(w, " %-*s %s\n", maxNameLen, c.Name, c.Bri... | func ListQueue(w http.ResponseWriter, r *http.Request) {
qj := new(QueueList)
for _, q := range jobQueue {
j := QueueJob{
Job: q,
}
qj.Jobs = append(qj.Jobs, j)
}
b, _ := json.Marshal(qj)
fmt.Fprintf(w, "%s", string(b))
} | func (r *Replica) removeCmdsFromCommandQueue() {
} | func (d *Dentist) QueryQueue() *QueueQuery {
return (&DentistClient{config: d.config}).QueryQueue(d)
} | func (d *Dentist) QueryQueue() *QueueQuery {
return (&DentistClient{config: d.config}).QueryQueue(d)
} | func FlushCommands() error {
return theCommandQueue.Flush()
} | func (q *commandQueue) Enqueue(command command) {
// TODO: If dst is the screen, reorder the command to be the last.
q.commands = append(q.commands, command)
} | func (a *App) QueuedCommandsCleanup() {
for selectedCmd := range a.CommandScheduler.VacuumQueue {
go func() {
time.Sleep(time.Second * 3)
a.DmnLogFile.Log.Printf("Vacuuming %v\n", selectedCmd.CmdHash)
for foundIndex, cmd := range a.CommandScheduler.QueuedCommands {
if cmd.CmdHash == selectedCmd.CmdHash ... | func Display(ret []Command) {
w := tabwriter.NewWriter(os.Stdout, 2, 2, 4, ' ', 0)
defer w.Flush()
show := func(a, b, c, d interface{}) {
fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", a, b, c, d)
}
show("HASH", "COMMAND", "DESCRIPTION", "DURATION")
for _, c := range ret {
cmdHash := c.CmdHash[0:15]
var cmdString ... | func (queue *Queue) processCommand(command protocol.Command) {
log.Printf("Processing command of type [ %v ] with data [ %v ]", command.Type, command.Data)
} | func (s *RovingServerClient) FetchQueues() (*map[string]*types.InputCorpus, error) {
resp, err := s.makeRequest("GET", "queue", nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var queue map[string]*types.InputCorpus
encoder := json.NewDecoder(resp.Body)
encoder.Decode(&queue)
return &queue, n... | func (self *Client) QueueInfo() (*Reply, error) {
return self.call("S.QueueInfo", "", "")
} | func (c *client) Queue() ([]*Stage, error) {
var out []*Stage
uri := fmt.Sprintf(pathQueue, c.addr)
err := c.get(uri, &out)
return out, err
} | func main(){
q := queue.Queue{}
q.Add(7)
q.Add(8)
q.Add(9)
fmt.Println(q)
fmt.Println(q.Peek())
fmt.Println(q)
fmt.Println(q.Remove())
fmt.Println(q.Peek())
fmt.Println(q)
} | func (c *Client) Queue() <-chan cmd {
return c.cmd
} | func printElevatorQueue(elev et.Elevator) {
println("\t\t BT_HallUp \t BT_HallDown \t BT_Cab")
for floor := 0; floor < et.NumFloors; floor++ {
fmt.Printf("Floor %v: \t ", floor)
for button := 0; button < et.NumButtons; button++ {
if elev.Orders[floor][button].IsActive() {
print("TRUE \t\t ")
} else {
... | func PrintQueue(queue *v1beta1.Queue, writer io.Writer) {
_, err := fmt.Fprintf(writer, "%-25s%-8s%-8s%-8s%-8s%-8s%-8s\n",
Name, Weight, State, Inqueue, Pending, Running, Unknown)
if err != nil {
fmt.Printf("Failed to print queue command result: %s.\n", err)
}
_, err = fmt.Fprintf(writer, "%-25s%-8d%-8s%-8d%-8d... | func (app *state) Queue() []Transaction {
return app.queue
} | func (c *DentistClient) QueryQueue(d *Dentist) *QueueQuery {
query := &QueueQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := d.ID
step := sqlgraph.NewStep(
sqlgraph.From(dentist.Table, dentist.FieldID, id),
sqlgraph.To(queue.Table, queue.FieldID),
sqlg... | func (gc *GatewayClient) GetInQueueCommand() ([]types.MDMQueueCommandDetails, error) {
var mdmQueueCommandDetails []types.MDMQueueCommandDetails
req, httpError := http.NewRequest("GET", gc.host+"/im/types/Command/instances", nil)
if httpError != nil {
return mdmQueueCommandDetails, httpError
}
req.Header.Set("... | func (t *helpCommand) showAll(match matcher.Result, message msg.Message) {
t.once.Do(t.prebuildHelp)
var text string
text += "Hello <@" + message.User + ">, I’m your friendly slack-bot. You want me to show you around? :smile: \n"
text += "I currently listen to the following commands:\n"
lastCategory := bot.Cate... | func (c *NurseClient) QueryQueue(n *Nurse) *QueueQuery {
query := &QueueQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := n.ID
step := sqlgraph.NewStep(
sqlgraph.From(nurse.Table, nurse.FieldID, id),
sqlgraph.To(queue.Table, queue.FieldID),
sqlgraph.Edg... | func (ec *embargoClient) flushQueue() {
select {
case <-ec.embargo:
case <-ec.manager.finish:
return
}
ec.mu.RLock()
c := ec.peek()
ec.mu.RUnlock()
for c.call != nil {
ans := ec.client.Call(c.call)
go joinFulfiller(c.f, ans)
ec.mu.Lock()
ec.pop()
c = ec.peek()
ec.mu.Unlock()
}
} | func (c *Connection) Queue(format string, args ...interface{}) {
raw := fmt.Sprintf(format, args...)
if !strings.HasSuffix(raw, "\r\n") {
raw = fmt.Sprintf("%s\r\n", raw)
}
message, _ := ParseLine(raw)
c.MessageChan <- message
} | func (q *commandQueue) Enqueue(command command) {
q.commands = append(q.commands, command)
} | func (c *ConstructionClient) QueryQueue(co *Construction) *QueueItemQuery {
query := &QueueItemQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := co.ID
step := sqlgraph.NewStep(
sqlgraph.From(construction.Table, construction.FieldID, id),
sqlgraph.To(queuei... | func (act *BasicActivity) Display() (r []*LabelComment) {
act.mutex.Lock()
defer act.mutex.Unlock()
r = act.ApprovedQueue
act.ApprovedQueue = make([]*LabelComment, 0, QueueDefaultLength)
for _, c := range r {
c.Status = CommentStatusDisplayed
}
act.DisplayedCount += len(r)
return
} | func (em *managerImpl) Queue() chan<- Event {
return em.events
} | func (q *CommandQueue) Flush() error {
return toError(C.clFinish(q.clQueue))
} | func printAvailableCommands() {
fmt.Printf("Usage: %s [SUBCOMMAND] [OPTIONS]...\nAvailable subcommands:\n", os.Args[0])
keys := make([]string, 0, len(subcommands))
for k := range subcommands {
keys = append(keys, k)
}
sort.Strings(keys)
for _, name := range keys {
fmt.Printf("\t%s\n", name)
}
} | func (ab *apmBacklog) flushQueueBacklog() {
buf := buffers.Get().(*bytes.Buffer)
for _, queue := range ab.queues {
err := json.NewEncoder(buf).Encode(queue)
if err != nil {
logger.Printf("Backlog queue failed = %s", err)
continue
}
req, err := http.NewRequest(
http.MethodPut,
fmt.Sprintf("%s/api... | func (q *LinkQueue) Print() {
curr := q.front
for curr != nil {
fmt.Printf("%v ", curr.Data)
curr = curr.Next
}
fmt.Println()
} | func (c *PatientClient) QueryQueue(pa *Patient) *QueueQuery {
query := &QueueQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := pa.ID
step := sqlgraph.NewStep(
sqlgraph.From(patient.Table, patient.FieldID, id),
sqlgraph.To(queue.Table, queue.FieldID),
sq... | func (queue *Queue) String() string {
el := queue.front
var stringBuilder string
stringBuilder = fmt.Sprintln("BEGIN: Queue elements")
for el != nil {
stringBuilder = fmt.Sprintln(stringBuilder, el.value)
el = el.next
}
stringBuilder = fmt.Sprintln(stringBuilder, "END")
return stringBuilder
} | func (h ShowQueueHandler) Handle(params queueop.ShowQueueParams) middleware.Responder {
// TODO: Check user is authorized to see office queues
lifecycleState := params.QueueType
MoveQueueItems, err := models.GetMoveQueueItems(h.db, lifecycleState)
if err != nil {
h.logger.Error("Loading Queue", zap.String("State... | func FetchQueue(w http.ResponseWriter, r *http.Request) {
js, err := model.FetchQueue()
w.Header().Set("Content-Type", "application/json")
if err != nil {
if err.Error() == "Not found" {
w.WriteHeader(http.StatusNotFound)
w.Write(js)
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]b... | func (s *Server) Queues(w http.ResponseWriter, r *http.Request) {
team, err := s.currentTeam(w, r)
if err != nil {
s.unauthorized(w, err)
return
}
q, err := models.NewQueue(s.pubsubAddr)
if err != nil {
Error(w, http.StatusInternalServerError, err, "failed to initialized queue")
return
}
queues, err := ... | func (vi *VoiceInstance) showPlayQueue(m *discordgo.MessageCreate) {
if vi.playQueue.Empty() {
vi.sendMessageToChannel(m.ChannelID, "Play queue is empty.")
return
}
_, err := vi.sendEmbedPlayQueueMessage(m.ChannelID)
if err != nil {
vi.sendErrorMessageToChannel(m.ChannelID)
return
}
} | func (cq *ConstructionQuery) QueryQueue() *QueueItemQuery {
query := &QueueItemQuery{config: cq.config}
query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
if err := cq.prepareQuery(ctx); err != nil {
return nil, err
}
selector := cq.sqlQuery()
if err := selector.Err(); err != nil {
... | func Display(results chan *Result) {
// The channel blocks until a result is written to the channel.
// Once the channel is closed the for loop terminates.
for result := range results {
log.Printf("%s:\n%s\n\n", result.Field, result.Content)
}
} | func (q *UniqueQueue) Queue() <-chan string {
return q.queue
} | func ExampleQueue() {
queue := NewQueue()
// Insert (Enqueue) in the queue, the numbers: 1, 2, 3, 4, 5
for i := 1; i <= 5; i++ {
queue.Enqueue(It(i))
}
// Dequeue.
for item, cont := queue.Dequeue(); cont; item, cont = queue.Dequeue() {
fmt.Printf("Item is number: %s\n", item.String())
}
// Output:
// Ite... | func (q *DynamicQueue) String() string {
q.lock.RLock()
defer q.lock.RUnlock()
var b bytes.Buffer
for _, e := range q.data {
b.WriteString(fmt.Sprintf("%v ", e))
}
return b.String()
} | func (o *Object) ProcessCommand() {
var (
c Command
ok bool
tickMode bool
)
//wait for active
<-o.waitActive
//deamon or no
if o.Waitor != nil {
o.Waitor.Add(1)
defer o.Waitor.Done()
}
if o.opt.Interval > 0 && o.sinker != nil && o.timer == nil {
o.timer = time.NewTicker(o.opt.Interva... | func (s *StringLinkedListQueue) String() {
s.lock.RLock()
if s.size == 0 {
fmt.Println("Queue is empty!")
}
j := 0
node := s.head
for j < s.size {
fmt.Print(node.content)
if j != s.size-1 {
fmt.Print("-->")
} else {
fmt.Println("")
}
node = node.next
j++
}
s.lock.RUnlock()
} | func (c *CityClient) QueryQueue(ci *City) *QueueItemQuery {
query := &QueueItemQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := ci.ID
step := sqlgraph.NewStep(
sqlgraph.From(city.Table, city.FieldID, id),
sqlgraph.To(queueitem.Table, queueitem.FieldID),
... | func (sq *SqsQueue) getAll(configObj config.Config) ([]*string, error) {
result := []*string{}
paginator := func(output *sqs.ListQueuesOutput, lastPage bool) bool {
result = append(result, output.QueueUrls...)
return !lastPage
}
param := &sqs.ListQueuesInput{
MaxResults: awsgo.Int64(10),
}
err := sq.Client... | func QueueStats(c *gin.Context) {
queues := queue.Queue.GetOpenQueues()
stats := queue.Queue.CollectStats(queues)
c.JSON(http.StatusOK, stats)
} | func (hd *HandleController) flushQueue() {
hd.messages = nil
hd.messagesSinceLastReload = nil
} | func (cl CommandList) PrintAll() {
for _, v := range cl {
if !v.Hidden {
v.help()
}
}
} | func (m *PingMessage) Queue() string {
return ""
} | func (o QueuingConfigurationOutput) Queues() pulumi.IntPtrOutput {
return o.ApplyT(func(v QueuingConfiguration) *int { return v.Queues }).(pulumi.IntPtrOutput)
} | func (taskBolt *TaskBolt) ReadQueue(n int) []*tes.Task {
tasks := make([]*tes.Task, 0)
taskBolt.db.View(func(tx *bolt.Tx) error {
// Iterate over the TasksQueued bucket, reading the first `n` tasks
c := tx.Bucket(TasksQueued).Cursor()
for k, _ := c.First(); k != nil && len(tasks) < n; k, _ = c.Next() {
id :... | func (c *UserClient) QueryQueue(u *User) *QueueItemQuery {
query := &QueueItemQuery{config: c.config}
query.path = func(ctx context.Context) (fromV *sql.Selector, _ error) {
id := u.ID
step := sqlgraph.NewStep(
sqlgraph.From(user.Table, user.FieldID, id),
sqlgraph.To(queueitem.Table, queueitem.FieldID),
... | func (qm *ServerMgr) updateQueue(logTimes bool) (err error) {
logger.Debug(3, "(updateQueue) wait for lock")
qm.queueLock.Lock()
defer qm.queueLock.Unlock()
logger.Debug(3, "(updateQueue) starting")
var tasks []*Task
tasks, err = qm.TaskMap.GetTasks()
if err != nil {
return
}
if true {
if len(tasks) > 0... | func (s *UIState) processQueue() {
for {
select {
case f := <-s.queueChan:
f()
default:
return
}
}
} | func (s *Scheduler) readResultsQueue(ctx context.Context) {
for {
// Give the shutdown signal precedence
select {
case <-ctx.Done():
return
default:
}
select {
case <-ctx.Done():
return
case elem, ok := <-s.resultsQueue.Consume():
if !ok {
return
}
s.handleResult(ctx, elem.(Result))... | func (s *Server) QueueExecute(ctx context.Context, req *pb.ExecuteRequest) (*pb.ExecuteResponse, error) {
// Pre clean the queue
nq := []*queueEntry{}
for _, q := range s.archive {
if !q.req.GetReadyForDeletion() {
nq = append(nq, q)
}
}
s.archive = nq
archive.Set(float64(len(s.archive)))
Backlog.Set(flo... | func printQueued(r *git.Repository, j *job.Job) string {
var info string
switch jt := j.JobType; jt {
case job.FetchJob:
info = blue.Sprint(queuedSymbol) + ws + "(" + blue.Sprint("fetch") + ws + r.State.Remote.Name + ")"
case job.PullJob:
info = magenta.Sprint(queuedSymbol) + ws + "(" + magenta.Sprint("pull") +... | func (this *Job) displayAppJobs(appid string) {
aid := this.connectMysqlCluster(appid)
lines := make([]string, 0)
header := "Topic|Type|JobId|Due|Payload"
lines = append(lines, header)
// FIXME does not respect appid, show all now
this.forSortedJobQueues(func(topic string) {
table := jm.JobTable(topic)
archi... | func (q *Queue) String() string {
if q == nil {
return "<nil>"
}
return q.list.String()
} | func (queue *Queue) String() string {
str := "PriorityQueue\n"
values := make([]string, queue.heap.Size(), queue.heap.Size())
for index, value := range queue.heap.Values() {
values[index] = fmt.Sprintf("%v", value)
}
str += strings.Join(values, ", ")
return str
} | func (h *BaseHandler) Queue() <-chan *Message {
return h.queue
} | func (q *commandQueue) Flush() error {
// glViewport must be called at least at every frame on iOS.
opengl.GetContext().ResetViewportSize()
n := 0
lastN := 0
for _, g := range q.commandGroups() {
for _, c := range g {
n += c.NumVertices()
}
if 0 < n-lastN {
// Note that the vertices passed to BufferSub... | func (store *QueueStore) List() ([]string, error) {
store.RLock()
defer store.RUnlock()
return store.list()
} | func printCommands(cmds []string) {
for _, cmd := range cmds {
fmt.Println(cmd)
}
} | func (q *QueueNone) getQueue() []*files.Stats {
// Filtering trick
// https://github.com/golang/go/wiki/SliceTricks#filtering-without-allocating
q.buffer = q.buffer[:0]
for _, fileStats := range q.files {
q.buffer = append(q.buffer, fileStats)
}
return q.buffer
} | func (s *Segmenter) printQ() {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("Q #%d: ", s.deque.Len()))
for i := 0; i < s.deque.Len(); i++ {
var a atom
a.r, a.penalty0, a.penalty1 = s.deque.At(i)
sb.WriteString(fmt.Sprintf(" <- %s", a.String()))
}
sb.WriteString(" .")
CT().Debugf(sb.String())
} | func (rc Commands) String() string {
// TODO sorting
var res string
for k, v := range rc {
res += fmt.Sprintf("%s - %s\n", k, v.Short)
}
return res
} | func Queue() []FloorState {
return <-getQueueCopy
} | func (queue LinkedListQueue) String() string {
return queue.list.String()
} | func (s *Session) ClearQueue() {
s.sendAction(actionClearQueue, "")
} | func (o EnvironmentOutput) Queues() pulumi.StringArrayOutput {
return o.ApplyT(func(v *Environment) pulumi.StringArrayOutput { return v.Queues }).(pulumi.StringArrayOutput)
} | func (gcp *GCPCloud) QueueReceive(queue <-chan filesystem.FsEvent) {
for evt := range queue {
fmt.Printf("gcp provider: %s operation recvd for %s\n", evt.Operation, evt.Filename)
}
} | func (q *TaskQueue) String() string {
var buf strings.Builder
var index int
var qLen = q.Length()
q.Iterate(func(t task.Task) {
buf.WriteString(fmt.Sprintf("[%s,id=%10.10s]", t.GetDescription(), t.GetId()))
index++
if index == qLen {
return
}
buf.WriteString(", ")
})
return buf.String()
} | func GetQueue(num int) ([]Query, error) {
queries := []Query{}
q := Query{}
var priority sql.NullString
//create sql query
rows, err := SQLDB.Query("SELECT key,text,type,priority FROM queries ORDER BY datetime(priority) DESC LIMIT (?)", num)
defer rows.Close() //close query connection when function returns
if er... | func (m *Manager) next(queue string, command *pm.Command) error {
conn := m.pool.Get()
defer conn.Close()
payload, err := redis.ByteSlices(conn.Do("BLPOP", queue, 10))
if err != nil {
return err
}
if payload == nil || len(payload) < 2 {
return redis.ErrNil
}
return json.Unmarshal(payload[1], command)
} | func (m *Menu) ShowCommand() {
if m.Cursor >= len(m.Commands) {
fmt.Println("Cursor exceed array")
return
}
c := m.Commands[m.Cursor]
m.p.Clear()
runNow := (c.Args == nil || len(c.Args) == 0 || m.argIndex >= len(c.Args))
c.breadCrum = m.BreadCrum()
if !runNow {
m.printPageHearder(c.BreadCrum()+" > "+c.Ar... | func Enqueue(ctx context.Context, c *jasper.Command, q amboy.Queue) error {
jobs, err := Jobs(c)
if err != nil {
return err
}
catcher := &erc.Collector{}
for _, j := range jobs {
catcher.Add(q.Put(ctx, j))
}
return catcher.Resolve()
} | func (b *Batch) Queue(name string, arguments []interface{}, parameterOIDs []pgtype.OID, resultFormatCodes []int16) (err error) {
q, err := b.qm.getQuery(name)
if err != nil {
return
}
b.Pgx.Queue(q.getSQL(), arguments, parameterOIDs, resultFormatCodes)
return
} | func (o QueuingConfigurationPtrOutput) Queues() pulumi.IntPtrOutput {
return o.ApplyT(func(v QueuingConfiguration) *int { return v.Queues }).(pulumi.IntPtrOutput)
} | func (q *Queue) String() string {
return fmt.Sprintf("[%v, %v, %v, %v]", q.handle, q.qhandle, q.fifo, q.prefix)
} | func (qm *SQSManager) List() ([]string, error) {
response, err := qm.qc.ListQueues(
&sqs.ListQueuesInput{QueueNamePrefix: &qm.namespace})
if err != nil {
return nil, errors.Wrap(err, "problem listing sqs queues")
}
listed := make([]string, len(response.QueueUrls))
for i, qurl := range response.QueueUrls {
l... | func (authHandler authHandler) handleQueue() *Queue {
packet, err := authHandler.WaitForPacket()
if err != nil {
fmt.Println(err)
}
queue, err := NewQueue(packet)
if err != nil {
fmt.Println(err)
} else {
queue.LogQueuePosition()
}
return queue
} | func (q *commandQueue) commandGroups() [][]command {
cs := q.commands
var gs [][]command
quads := 0
for 0 < len(cs) {
if len(gs) == 0 {
gs = append(gs, []command{})
}
c := cs[0]
switch c := c.(type) {
case *drawImageCommand:
if maxQuads >= quads+c.quadsNum() {
quads += c.quadsNum()
break
... | func (q *Queue) String() string {
var result bytes.Buffer
result.WriteByte('[')
j := q.front
for i := 0; i < q.size; i++ {
result.WriteString(fmt.Sprintf("%v", q.array[j]))
if i < q.size-1 {
result.WriteByte(' ')
}
j = (j + 1) % q.capacity
}
result.WriteByte(']')
return result.String()
} | [
"0.7760141",
"0.6652625",
"0.6611176",
"0.6334599",
"0.62886024",
"0.618715",
"0.60144943",
"0.5930474",
"0.5784326",
"0.5762566",
"0.57483506",
"0.5733703",
"0.5733104",
"0.5730854",
"0.5721683",
"0.56112474",
"0.560985",
"0.56081724",
"0.56081724",
"0.55944794",
"0.5581346"... |
HoldQueue display all hold queue entries | func HoldQueue(clientInstance *client.AdabasAdmin, dbid int, auth runtime.ClientAuthInfoWriter) error {
params := online.NewGetDatabaseHoldQueueParams()
rfc3339 := true
params.Rfc3339 = &rfc3339
params.Dbid = float64(dbid)
resp, err := clientInstance.Online.GetDatabaseHoldQueue(params, auth)
if err != nil {
swi... | func (q *Queue) Display() {
elem := q.queue.Front()
for elem != nil {
fmt.Println(elem.Value)
elem = elem.Next()
}
} | func DisplayQueue(ret []Command) {
w := tabwriter.NewWriter(os.Stdout, 2, 2, 4, ' ', 0)
defer w.Flush()
show := func(a, b, c, d interface{}) {
fmt.Fprintf(w, "%v\t%v\t%v\t%v\n", a, b, c, d)
}
show("HASH", "COMMAND", "DESCRIPTION", "STATUS")
for _, c := range ret {
cmdHash := c.CmdHash[0:15]
var cmdStri... | func (q *Q) Display() {
if incrementer <= 0 {
fmt.Println(ErrQueueIsEmpty)
} else {
fmt.Println(incrementer)
q.container.Display()
}
} | func (S *Sakamoto) displayQueue(args []string) {
err := S.getVoiceConn()
if err != nil {
log.Println(err.Error())
return
}
message, total := S.getInfoForEmbed()
// Setup Pagination for a long song queue
pageIndexs := [][2]int{}
totalMessageLen, currentPageLen, lastPage, lastID := 0, 0, 0, 0
for id, value... | func (q *Queue) Print() {
for _, item := range q.elems {
fmt.Printf("%v ", item)
}
fmt.Println()
} | func (q *Queue) Display() {
node := q.Head.Right
fmt.Printf("%d - [", q.Length)
for i := 0; i < q.Length; i++ {
fmt.Printf("{%s}", node.Value)
if i < q.Length-1 {
fmt.Printf("<-->")
}
node = node.Right
}
fmt.Println("]")
} | func getQueue(queue []int){
if len(queue) == 0 {
fmt.Println()
fmt.Println("Ready Queue: Currently empty.")
fmt.Println()
}else{
fmt.Printf(" -")
for i:= 0; i < len(queue); i++{
fmt.Printf("-----")
}
fmt.Printf("\nReady Queue: |")
for i := 0; i < len(queue); i++{
fmt.Printf(" P%d... | func printElevatorQueue(elev et.Elevator) {
println("\t\t BT_HallUp \t BT_HallDown \t BT_Cab")
for floor := 0; floor < et.NumFloors; floor++ {
fmt.Printf("Floor %v: \t ", floor)
for button := 0; button < et.NumButtons; button++ {
if elev.Orders[floor][button].IsActive() {
print("TRUE \t\t ")
} else {
... | func (c *Cache) Display() {
c.Queue.Display()
} | func (qw *QueueWrapper) Get(number int64) ([]interface{}, error) {
qw.queueLock.Lock()
defer qw.queueLock.Unlock()
// Call get to underlying queue
poppedItems, error := qw.simpleQueue.Get(number)
// Start subtracting the size of the log
for _, item := range poppedItems {
qw.queueSize -... | func Queue() []FloorState {
return <-getQueueCopy
} | func (q Queue) Print() {
fmt.Println(q.que)
} | func (act *BasicActivity) Display() (r []*LabelComment) {
act.mutex.Lock()
defer act.mutex.Unlock()
r = act.ApprovedQueue
act.ApprovedQueue = make([]*LabelComment, 0, QueueDefaultLength)
for _, c := range r {
c.Status = CommentStatusDisplayed
}
act.DisplayedCount += len(r)
return
} | func (h ShowQueueHandler) Handle(params queueop.ShowQueueParams) middleware.Responder {
// TODO: Check user is authorized to see office queues
lifecycleState := params.QueueType
MoveQueueItems, err := models.GetMoveQueueItems(h.db, lifecycleState)
if err != nil {
h.logger.Error("Loading Queue", zap.String("State... | func main(){
q := queue.Queue{}
q.Add(7)
q.Add(8)
q.Add(9)
fmt.Println(q)
fmt.Println(q.Peek())
fmt.Println(q)
fmt.Println(q.Remove())
fmt.Println(q.Peek())
fmt.Println(q)
} | func (w *Client) ViewRequestQueue() (output [][]byte, err error) {
var (
temp []byte
errorCount int
)
for name := range w.requestQueue {
for i := range w.requestQueue[name] {
temp, err = json.Marshal(w.requestQueue[name][i])
if err != nil {
fmt.Println(err)
errorCount++
if errorCount >... | func (lru *HandlerLRU) Dump() {
lru.mutex.Lock()
defer lru.mutex.Unlock()
fmt.Printf("LRU Entries (recent first):\n")
for e := lru.hqueue.Front(); e != nil; e = e.Next() {
h := e.Value.(*Handler)
fmt.Printf("> %s\n", h.name)
}
} | func (q *LinkQueue) Print() {
curr := q.front
for curr != nil {
fmt.Printf("%v ", curr.Data)
curr = curr.Next
}
fmt.Println()
} | func UnboundedBoxQueue(invoker MailInvoker) *BoxQueue {
bq := &BoxQueue{
capped: -1,
invoker: invoker,
}
bq.pushCond = sync.NewCond(&bq.bm)
return bq
} | func ExampleQueue() {
queue := NewQueue()
// Insert (Enqueue) in the queue, the numbers: 1, 2, 3, 4, 5
for i := 1; i <= 5; i++ {
queue.Enqueue(It(i))
}
// Dequeue.
for item, cont := queue.Dequeue(); cont; item, cont = queue.Dequeue() {
fmt.Printf("Item is number: %s\n", item.String())
}
// Output:
// Ite... | func (app *state) Queue() []Transaction {
return app.queue
} | func printPendingRecordList(clusterPendingTasksResp *elastic.ClusterPendingTasksResponse) error {
if clusterPendingTasksResp == nil {
return nil
}
display := NewTableDisplay()
display.AddRow([]string{"insertorder", "priority", "source", "timeInQueueMillis", "timeInQueue"})
for _, task := range clusterPendingTas... | func (q *QueueNone) getQueue() []*files.Stats {
// Filtering trick
// https://github.com/golang/go/wiki/SliceTricks#filtering-without-allocating
q.buffer = q.buffer[:0]
for _, fileStats := range q.files {
q.buffer = append(q.buffer, fileStats)
}
return q.buffer
} | func (q *NoStoreQueue) List() []interface{} {
return []interface{}{}
} | func (queue *Queue) String() string {
el := queue.front
var stringBuilder string
stringBuilder = fmt.Sprintln("BEGIN: Queue elements")
for el != nil {
stringBuilder = fmt.Sprintln(stringBuilder, el.value)
el = el.next
}
stringBuilder = fmt.Sprintln(stringBuilder, "END")
return stringBuilder
} | func (selfPtr *RoundRobinQueue) Enlist(group string, item interface{}) {
selfPtr.globalLock.Lock()
defer selfPtr.globalLock.Unlock()
if len(selfPtr.priorityMap) == 0 {
selfPtr.defaultBox = append(selfPtr.defaultBox, item)
} else {
selfPtr.checkIfGroupExists(group)
groupMessageBox := selfPtr.groupMessageBoxM... | func (q *Queue) DumpString() string {
q.mu.RLock()
defer q.mu.RUnlock()
s := "# Queue status\n\n"
s += fmt.Sprintf("date: %v\n", time.Now())
s += fmt.Sprintf("length: %d\n\n", len(q.q))
for id, item := range q.q {
s += fmt.Sprintf("## Item %s\n", id)
item.Lock()
s += fmt.Sprintf("created at: %s\n", item.Cr... | func (q *queue) ReleaseAll() error {
_, err := q.conn.Do(tarantool.NewCallRequest(q.cmds.releaseAll)).Get()
return err
} | func enqueue(pool *Pool, hp *HackerPrinter) {
hp.timesUsed++
fmt.Printf("Hacker %s enters the queue for %d time\n", hp.name, hp.timesUsed)
//If timeout happens before the send in queue, then "the hacker leaves"
select {
case pool.GetQueue() <- hp:
hp.waitForFinishPrint(pool)
return
case <-hp.tired:
fmt.Prin... | func (q *statsQueue) Clear() {
q.rwl.Lock()
defer q.rwl.Unlock()
q.back = -1
q.front = 0
q.size = 0
q.totalPkgSize = 0
} | func (authHandler authHandler) handleQueue() *Queue {
packet, err := authHandler.WaitForPacket()
if err != nil {
fmt.Println(err)
}
queue, err := NewQueue(packet)
if err != nil {
fmt.Println(err)
} else {
queue.LogQueuePosition()
}
return queue
} | func (s *RovingServerClient) FetchQueues() (*map[string]*types.InputCorpus, error) {
resp, err := s.makeRequest("GET", "queue", nil)
if err != nil {
return nil, err
}
defer resp.Body.Close()
var queue map[string]*types.InputCorpus
encoder := json.NewDecoder(resp.Body)
encoder.Decode(&queue)
return &queue, n... | func (ab *apmBacklog) flushQueueBacklog() {
buf := buffers.Get().(*bytes.Buffer)
for _, queue := range ab.queues {
err := json.NewEncoder(buf).Encode(queue)
if err != nil {
logger.Printf("Backlog queue failed = %s", err)
continue
}
req, err := http.NewRequest(
http.MethodPut,
fmt.Sprintf("%s/api... | func (store *QueueStore) List() ([]string, error) {
store.RLock()
defer store.RUnlock()
return store.list()
} | func (bq *BoxQueue) Clear() {
bq.pushCond.L.Lock()
if bq.isEmpty() {
bq.pushCond.L.Unlock()
return
}
bq.tail = nil
bq.head = nil
bq.pushCond.L.Unlock()
bq.pushCond.Broadcast()
} | func (qm *ServerMgr) updateQueue(logTimes bool) (err error) {
logger.Debug(3, "(updateQueue) wait for lock")
qm.queueLock.Lock()
defer qm.queueLock.Unlock()
logger.Debug(3, "(updateQueue) starting")
var tasks []*Task
tasks, err = qm.TaskMap.GetTasks()
if err != nil {
return
}
if true {
if len(tasks) > 0... | func (queue *Queue) String() string {
str := "PriorityQueue\n"
values := make([]string, queue.heap.Size(), queue.heap.Size())
for index, value := range queue.heap.Values() {
values[index] = fmt.Sprintf("%v", value)
}
str += strings.Join(values, ", ")
return str
} | func (pq *PriorityQueue) Print() {
fmt.Print("[")
for i := range pq.ipq.items {
fmt.Print(pq.ipq.items[i].value, ", ")
}
fmt.Println("]")
} | func (hd *HandleController) flushQueue() {
hd.messages = nil
hd.messagesSinceLastReload = nil
} | func (c *client) Queue() ([]*Stage, error) {
var out []*Stage
uri := fmt.Sprintf(pathQueue, c.addr)
err := c.get(uri, &out)
return out, err
} | func (r *Renter) DownloadQueue() []modules.DownloadInfo {
lockID := r.mu.RLock()
defer r.mu.RUnlock(lockID)
// order from most recent to least recent
downloads := make([]modules.DownloadInfo, len(r.downloadQueue))
for i := range r.downloadQueue {
d := r.downloadQueue[len(r.downloadQueue)-i-1]
downloads[i] = m... | func LenQueue() int {
return len(ListQueue)
} | func FetchQueue(w http.ResponseWriter, r *http.Request) {
js, err := model.FetchQueue()
w.Header().Set("Content-Type", "application/json")
if err != nil {
if err.Error() == "Not found" {
w.WriteHeader(http.StatusNotFound)
w.Write(js)
} else {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]b... | func (gcp *GCPCloud) QueueReceive(queue <-chan filesystem.FsEvent) {
for evt := range queue {
fmt.Printf("gcp provider: %s operation recvd for %s\n", evt.Operation, evt.Filename)
}
} | func (h *PQueue) Len() int { return len(*h) } | func (jt *Workers) Take() {
jt.wg.Add(1)
<-jt.queue
} | func ListQueue(w http.ResponseWriter, r *http.Request) {
qj := new(QueueList)
for _, q := range jobQueue {
j := QueueJob{
Job: q,
}
qj.Jobs = append(qj.Jobs, j)
}
b, _ := json.Marshal(qj)
fmt.Fprintf(w, "%s", string(b))
} | func (c *CWProcessor) waitForQueue(maxLen int) {
for {
if len(c.metricsList) > maxLen {
time.Sleep(100 * time.Millisecond)
} else {
return
}
}
} | func (s *SubmitQueue) Reset() {
for _, entry := range s.Entries {
entry.Reset()
}
} | func (queue *BroadcastQueue) Release() {
for _, o := range queue.out {
close(o)
}
// empty the list
queue.out = make([]chan Message, 0, 10)
} | func (q *DynamicQueue) String() string {
q.lock.RLock()
defer q.lock.RUnlock()
var b bytes.Buffer
for _, e := range q.data {
b.WriteString(fmt.Sprintf("%v ", e))
}
return b.String()
} | func BoundedBoxQueue(capped int, method Strategy, invoker MailInvoker) *BoxQueue {
bq := &BoxQueue{
capped: capped,
strategy: method,
invoker: invoker,
}
bq.pushCond = sync.NewCond(&bq.bm)
return bq
} | func (s *queueUnitLister) List(selector labels.Selector) (ret []*v1alpha1.QueueUnit, err error) {
err = cache.ListAll(s.indexer, selector, func(m interface{}) {
ret = append(ret, m.(*v1alpha1.QueueUnit))
})
return ret, err
} | func EnQueue(n any) {
ListQueue = append(ListQueue, n)
} | func (d *Dict) PushQueue(cmd DictCmd) {
d.Cmds <- cmd
} | func (q *APTQueue) run() {
if !q.Context.Config.IsE2ETest() {
q.Context.Logger.Info("apt_queue invoked but is doing nothing because this service is probably no longer necessary, except in end-to-end tests.")
q.Context.Logger.Info("We are evaluating whether or not to remove this service entirely from our production... | func (q Queue) Summary() QueueSummary {
return QueueSummary{
ID: q.ID,
ReceivedAt: q.ReceivedAt.Unix(),
Payload: q.Payload,
}
} | func FlushTlbAll() | func (w *LimitedQueues) Refresh(wfr *v1alpha1.WorkflowRun) {
q, ok := w.Queues[key(wfr)]
if !ok {
log.WithField("key", key(wfr)).Warn("Queue not exist")
return
}
q.Refresh(wfr)
} | func (eq *Queue) Clear(round uint64) {
eq.lock.Lock()
defer eq.lock.Unlock()
newEntries := make(map[uint64]map[uint8][]message.Message)
eq.items = 0
for r := range eq.entries {
if r > round {
newEntries[r] = make(map[uint8][]message.Message)
for s, m := range eq.entries[r] {
newEntries[r][s] = m
... | func (s *UIState) processQueue() {
for {
select {
case f := <-s.queueChan:
f()
default:
return
}
}
} | func (q *Queue) Clear() {
q.heap, q.table = nil, make(map[Timer]*timerData)
} | func (queue LinkedListQueue) String() string {
return queue.list.String()
} | func (qm *QueueManager) Dispatch(queue string, key string) {
for {
// this is blocking operation
env, err := rdsPool.Dequeue(queue)
if err != nil {
glog.Error(err.Error())
}
// persist to db
if err = chatable.PersistEnvelope(env, store.UserStore,
store.EnvelopeStore, store.ThreadStore); err != nil {... | func BackQueue() any {
return ListQueue[len(ListQueue)-1]
} | func TaskQueue() taskqueue.RawInterface { return dummyTQInst } | func TestQueue(t *testing.T) {
dq := NewDequeue()
for i := 0; i < 10; i++ {
dq.Push(i)
}
dq.Foreach(func(v interface{}) {
fmt.Printf("%v ", v)
})
fmt.Println()
fmt.Println("size: ", dq.Size())
peek := dq.Peek()
fmt.Println("peek value: ", peek)
if ok, i := dq.Pop(); ok {
fmt.Println("pop success: ", i)
... | func PrintQueue(queue *v1beta1.Queue, writer io.Writer) {
_, err := fmt.Fprintf(writer, "%-25s%-8s%-8s%-8s%-8s%-8s%-8s\n",
Name, Weight, State, Inqueue, Pending, Running, Unknown)
if err != nil {
fmt.Printf("Failed to print queue command result: %s.\n", err)
}
_, err = fmt.Fprintf(writer, "%-25s%-8d%-8s%-8d%-8d... | func (l *Lidarr) GetQueue(maxRecords int) (*Queue, error) {
if maxRecords < 1 {
maxRecords = 1
}
params := make(url.Values)
params.Set("sortKey", "timeleft")
params.Set("sortDir", "asc")
params.Set("pageSize", strconv.Itoa(maxRecords))
params.Set("includeUnknownArtistItems", "true")
var queue Queue
err :=... | func (q *UnboundedQueue) Clear() {
q.nodes.Init()
} | func (q *TimeQueue) PopAll(release bool) []*Message {
q.lock.Lock()
defer q.lock.Unlock()
result := make([]*Message, 0, q.messages.Len())
for message := q.messages.popMessage(); message != nil; message = q.messages.popMessage() {
result = append(result, message)
}
if release {
q.releaseCopyToChan(result)
}
... | func CommandQueue(clientInstance *client.AdabasAdmin, dbid int, auth runtime.ClientAuthInfoWriter) error {
params := online.NewGetDatabaseCommandQueueParams()
rfc3339 := true
params.Rfc3339 = &rfc3339
params.Dbid = float64(dbid)
resp, err := clientInstance.Online.GetDatabaseCommandQueue(params, auth)
if err != ni... | func (ph *PiHTopItems) ShowBlocked() {
reverseMapBlocked := make(map[int]string)
var freqBlocked []int
for k, v := range ph.Blocked {
reverseMapBlocked[v] = k
freqBlocked = append(freqBlocked, v)
}
sort.Ints(freqBlocked)
fmt.Println("=== Blocked domains over last 24h:")
for i := len(freqBlocked) - 1; i >=... | func (hpq *HandPriorityQueue) Len() int { return len(hpq.Queue) } | func (a *App) QueuedCommandsCleanup() {
for selectedCmd := range a.CommandScheduler.VacuumQueue {
go func() {
time.Sleep(time.Second * 3)
a.DmnLogFile.Log.Printf("Vacuuming %v\n", selectedCmd.CmdHash)
for foundIndex, cmd := range a.CommandScheduler.QueuedCommands {
if cmd.CmdHash == selectedCmd.CmdHash ... | func (store *QueueStore) List() []string {
store.RLock()
defer store.RUnlock()
return store.list()
} | func (vq *VolumeQueue) Outstanding() int {
return len(vq.outstanding)
} | func (bq *baseQueue) DrainQueue() {
ctx := bq.AnnotateCtx(context.TODO())
for repl := bq.pop(); repl != nil; repl = bq.pop() {
annotatedCtx := repl.AnnotateCtx(ctx)
if err := bq.processReplica(annotatedCtx, repl); err != nil {
helper.Println(5, err)
}
}
} | func TestLogBufferEnqueueDequeue(t *testing.T) {
lb := testEnqueue(t)
queueLen := len(lb.queue)
for i := 0; i < queueLen; i++ {
fmt.Println(i)
msg, err := lb.Dequeue()
require.NoError(t, err)
require.Equal(t, messages[i], msg)
}
require.Len(t, lb.queue, 0)
} | func Remove() {
// RemoveOldData()
removeLast()
removeLast()
removeLast()
log.Info("Q SIZE IS : ", GetQueueInstance().Size())
} | func (queue *LinkedListQueue) Clear() {
queue.list.Clear()
} | func (ec *embargoClient) flushQueue() {
select {
case <-ec.embargo:
case <-ec.manager.finish:
return
}
ec.mu.RLock()
c := ec.peek()
ec.mu.RUnlock()
for c.call != nil {
ans := ec.client.Call(c.call)
go joinFulfiller(c.f, ans)
ec.mu.Lock()
ec.pop()
c = ec.peek()
ec.mu.Unlock()
}
} | func DeQueue() any {
data := ListQueue[0]
ListQueue = ListQueue[1:]
return data
} | func (Q *Queue) Name() string { return Q.name } | func (c *Controller) drain(pq *PriorityQueue) {
for {
c.queriesMu.RLock()
if len(c.queries) == 0 {
c.queriesMu.RUnlock()
return
}
c.queriesMu.RUnlock()
// Wait for resources to free
q := <-c.queryDone
c.free(q)
c.queriesMu.Lock()
delete(c.queries, q.id)
c.queriesMu.Unlock()
// Peek at hea... | func (q *Queue) RemoveAll() {
for q.queue.Len() > 0 {
q.Dequeue()
}
} | func HandleBalanceLogQueue() {
logHelper.DebugNoContext("HandleBalanceLogQueue Started.")
rc := redisHelper.Pool().Get()
sleepDuration := time.Millisecond * 10
for {
time.Sleep(sleepDuration)
var b balance
popSucceed,err := redisHelper.LpopStruct(rc,"q:balance",&b)
if !popSucceed {
if sleepDuration < tim... | func (f *fixture) popQueue() {
f.T().Helper()
done := make(chan error)
go func() {
item, _ := f.q.Get()
_, err := f.r.Reconcile(f.Context(), item.(reconcile.Request))
f.q.Done(item)
done <- err
}()
select {
case <-time.After(time.Second):
f.T().Fatal("timeout waiting for workqueue")
case err := <-don... | func (queue *EventQueue) Flush() {
C.al_flush_event_queue((*C.ALLEGRO_EVENT_QUEUE)(queue))
} | func (c *Chain) PrintPool() {
pool := <-c.TransactionPool
c.TransactionPool <- pool
for _, tr := range pool {
fmt.Println(tr)
}
} | func (q *Queue) String() string {
if q == nil {
return "<nil>"
}
return q.list.String()
} | func (this *Job) displayAppJobs(appid string) {
aid := this.connectMysqlCluster(appid)
lines := make([]string, 0)
header := "Topic|Type|JobId|Due|Payload"
lines = append(lines, header)
// FIXME does not respect appid, show all now
this.forSortedJobQueues(func(topic string) {
table := jm.JobTable(topic)
archi... | func (tq *taskQueue) Len() int {
return tq.pQueue.Len()
} | func (s *Queue) Ready(now time.Time) []interface{} {
var ready []interface{}
for len(s.items) > 0 && !s.items[0].t.After(now) {
item := heap.Pop(&s.items).(*queueItem)
delete(s.m, item.key)
ready = append(ready, item.value)
}
return ready
} | func (q *BoundedQueue) Clear() {
close(q.nodes)
q.nodes = make(chan interface{}, cap(q.nodes))
} | func (l *LimitWindow) remove() {
l.Queue = l.Queue[1:]
} | func (q Must) List() [][]byte {
list, err := q.Queue.List()
if err != nil {
panic(err)
}
return list
} | func scanQueue(q *LimitedSortedQueue) {
q.lock.Lock()
defer q.lock.Unlock()
h := q.head
for h.next != nil {
// If the node's refresh time is old enough compared to the resync time
// (5 minutes by default) of WorkflowRun Controller, it means the WorkflowRun
// is actually removed from etcd somehow, so we wil... | func (q *MessageQueueMock) PullAll() []*entities.BannerEvent {
q.mu.Lock()
defer q.mu.Unlock()
res := q.q
q.q = make([]*entities.BannerEvent, 0)
return res
} | func cleanQueue(q *Queue) {
time.Sleep(50 * time.Millisecond)
q.Purge()
time.Sleep(50 * time.Millisecond)
} | [
"0.6445365",
"0.63507247",
"0.59322816",
"0.59161776",
"0.5807345",
"0.5773143",
"0.57558155",
"0.57536274",
"0.57382315",
"0.56513524",
"0.56317526",
"0.5568718",
"0.55347645",
"0.5427826",
"0.5381198",
"0.535568",
"0.53202236",
"0.5315816",
"0.5259089",
"0.52457434",
"0.519... |
Delete NS record by its DNS domain value | func deleteNsByValue(value string, payload *strings.Reader, c Config) {
var validValue = value
var nsID = 0
if !strings.HasSuffix(".", value) {
validValue += "."
nsID = GetId(validValue, c)
} else {
nsID = GetId(value, c)
}
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + strconv.Itoa(nsID) + ""
... | func deleteNsById(nsID string, payload *strings.Reader, c Config) {
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + nsID
send(url, DELETE, payload, c)
if filepath.Base(url) == "0" {
fmt.Println("Error: Wrong id -> ", url)
} else {
fmt.Println("Domain record deleted successfully ", url)
}
} | func deleteNsByName(name string, payload *strings.Reader, c Config) {
nsID := GetIdByName(name, c)
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + strconv.Itoa(nsID) + ""
send(url, DELETE, payload, c)
if filepath.Base(url) == "0" {
fmt.Println("Error: Wrong id -> ", url)
} else {
fmt.Println("Domai... | func (c *Client) DeleteRecord(ctx context.Context, domain string, id int) error {
endpoint, err := c.BaseURL.Parse(path.Join(c.BaseURL.Path, "dns", "delete", domain, strconv.Itoa(id)))
if err != nil {
return fmt.Errorf("failed to parse endpoint: %w", err)
}
respBody, err := c.do(ctx, endpoint, nil)
if err != ni... | func (n *GoName) DeleteDNSRecord(domain, recordID string) (data BasicResponse, err error) {
req := []byte(fmt.Sprintf(`{"record_id":"%s"}`, recordID))
err = n.post(fmt.Sprintf("/api/dns/delete/%s", domain), req, &data)
if data.Result.Failed() {
return data, fmt.Errorf("api error: %s", data.Result.String())
}
re... | func (dc *DOClient) DeleteDNS(id int) error {
return nil
} | func DomainDeleteHandler(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
domainName := vars["domain"]
err := model.GetModel().DeleteDomain(domainName)
// check validity of result
if err != nil {
w.WriteHeader(http.StatusBadRequest)
return
}
} | func DeleteDns(paras *Paras) *Response {
dns := &plugins.Dns{
DnsAddress: paras.Get("dnsAddress"),
}
return &Response{
Error: dns.DeleteDns(),
}
} | func (s *ChallSrv) DeleteDNSCNAMERecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.cnameRecords, host)
} | func (s *ChallSrv) DeleteDNSARecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.aRecords, host)
} | func (c *Client) DeleteDNSRecord(r *DNSRecord) (*SimpleResponse, error) {
if len(r.ID) == 0 {
err := fmt.Errorf("ID is empty")
return nil, IDisEmptyError.wrap(err)
}
if len(r.DNSDomainID) == 0 {
err := fmt.Errorf("DNSDomainID is empty")
return nil, IDisEmptyError.wrap(err)
}
url := fmt.Sprintf("/v2/dns/%... | func deleteDomain(c *godo.Client, name string) error {
resp, err := c.Domains.Delete(context.TODO(), name)
if err != nil {
return err
}
if err = handleResponse(resp); err != nil {
return err
}
return nil
} | func (g *LiveDNS) DeleteDomainRecord(fqdn, name, recordtype string) (err error) {
_, err = g.client.Delete("domains/"+fqdn+"/records/"+name+"/"+recordtype, nil, nil)
return
} | func (o *ClusterUninstaller) deleteDNSRecord(item cloudResource) error {
if len(o.CISInstanceCRN) > 0 {
return o.deleteCISDNSRecord(item)
}
return o.deleteDNSSvcDNSRecord(item)
} | func (iClient *IBloxClient) DeleteCNAMERecord(name, ipAddr, netview, cidr string) {
obj := ibclient.NewRecordCNAME(
ibclient.RecordCNAME{
Name: name,
View: netview,
Ea: iClient.ea,
},
)
res, err := iClient.getCNAMERecord(obj)
// If error or record doesn't exist, return
if err != nil || res == nil ||... | func (s *RecordsService) Delete(domain string, recordID string) (*Response, error) {
payload := s.client.CommonParams.toPayLoad()
payload.Add("domain_id", domain)
payload.Add("record_id", recordID)
returnedRecord := recordWrapper{}
res, err := s.client.post(methodRecordRemove, payload, &returnedRecord)
if err !... | func (api *API) DeleteDNSRecord(zone, id string) error {
z, err := api.ListZones(zone)
if err != nil {
return err
}
// TODO(jamesog): This is brittle, fix it
zid := z[0].ID
uri := "/zones/" + zid + "/dns_records/" + id
res, err := api.makeRequest("DELETE", uri, nil)
if err != nil {
fmt.Println("Error with m... | func (g *LiveDNS) DeleteDomainRecordsByName(fqdn, name string) (err error) {
_, err = g.client.Delete("domains/"+fqdn+"/records/"+name, nil, nil)
return
} | func Delete(c *deis.Client, appID string, domain string) error {
u := fmt.Sprintf("/v2/apps/%s/domains/%s", appID, domain)
res, err := c.Request("DELETE", u, nil)
if err == nil {
res.Body.Close()
}
return err
} | func (s *Session) TXTDelete(zone, fqdn string) error {
log.Printf("Delete TXT records with zone=%s and fqdn=%s", zone, fqdn)
var c http.Client
req, err := http.NewRequest(http.MethodDelete,
URI+"/REST/TXTRecord/"+zone+"/"+fqdn+"/", nil)
if err != nil {
return err
}
req.Header = s.authHeader
resp, err := c.D... | func (s Session) Delete(domain string) (response.Delete, error) {
resp := response.Delete{}
sld, tld := ParseDomain(domain)
cmd := s.CreateCommand("DeleteRegistration")
cmd.AddParam("sld", sld)
cmd.AddParam("tld", tld)
client := Client{&s}
data, err := client.DoRequest(cmd)
if err != nil {
return resp, err... | func (s *ChallSrv) DeleteDNSCAARecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.caaRecords, host)
} | func (r *Record) Delete(client *godo.Client) error {
_, err := client.Domains.DeleteRecord(context.TODO(), r.zoneName.String(""), r.ID)
return err
} | func DeleteHostname(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
var domain = params["domain"]
var hostnames = deleteHostname(domain)
respondWithJSON(w, http.StatusOK, hostnames)
} | func DeleteDNSRecord(record *DNSRecord, dnsProject, dnsZone string) error {
rec := MakeRecordSet(record)
svc, err := GetCloudDNSSvc()
if err != nil {
return err
}
deletion := &dns.Change{
Deletions: []*dns.ResourceRecordSet{rec},
}
return ChangeDNSRecord(deletion, svc, dnsProject, dnsZone)
} | func (s *Server) purgeDomain(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
domain, err := s.db.FetchByDomain(ps.ByName("name"))
if domain == nil || err != nil {
http.NotFound(w, r)
return
}
if _, err = s.db.DeleteByDomain(ps.ByName("name")); err != nil {
log.Infof("Can't delete entity %#v"... | func (c *Cache) RemoveRecord(domainName string, record Record) {
searchDomain := strings.ToLower(domainName)
recordToLower(&record)
c.createTree(searchDomain, record.Type)
c.Lock()
defer c.Unlock()
removeID := -1
for id, oldrecord := range c.Domain[searchDomain].QueryType[record.Type].HostRecord[record.Name] {
... | func removeDomainEntryInZone(delDomains []string) (error) {
// check if a domain were removed
DomainnameRemoved := false
// read zonefile
zoneFile, err := ioutil.ReadFile(Conf.Files.ZoneFile)
if err != nil {
// error while reading zonefile
return err
}
// split file in lines
lines := strings.Split(s... | func deleteRecord(c *godo.Client, zoneName string, recordID int) error {
resp, err := c.Domains.DeleteRecord(context.TODO(), zoneName, recordID)
if err != nil {
return fmt.Errorf("error applying changeset: %v", err)
}
if err = handleResponse(resp); err != nil {
return err
}
return nil
} | func (s *DomainService) Delete(domain string, scheduledDate time.Time) error {
req := s.client.NewRequest(methodDomainDelete, map[string]interface{}{
"domain": domain,
"scDate": scheduledDate.Format(time.RFC3339),
})
_, err := s.client.Do(*req)
return err
} | func (s *ChallSrv) DeleteDNSAAAARecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.aaaaRecords, host)
} | func (mdb *DB) DeleteFromDomain(filter *sqldb.DomainFilter) (sql.Result, error) {
var err error
var result sql.Result
switch {
case filter.ID != nil:
result, err = mdb.conn.Exec(deleteDomainByIDQry, shardID, filter.ID)
default:
result, err = mdb.conn.Exec(deleteDomainByNameQry, shardID, filter.Name)
}
return... | func (a *actuator) Delete(ctx context.Context, log logr.Logger, dns *extensionsv1alpha1.DNSRecord, _ *extensionscontroller.Cluster) error {
// Create AWS client
credentials, err := aws.GetCredentialsFromSecretRef(ctx, a.client, dns.Spec.SecretRef, true)
if err != nil {
return fmt.Errorf("could not get AWS credenti... | func (ns *Netstorage) Delete(nsPath string) (*http.Response, string, error) {
return ns._request(map[string]string{
"action": "delete",
"method": "POST",
"path": nsPath,
})
} | func (c *Itsyouonline) DeleteOrganizaitonDNS(dnsname, globalid string, headers, queryParams map[string]interface{}) (*http.Response, error) {
qsParam := buildQueryString(queryParams)
// create request object
req, err := http.NewRequest("DELETE", rootURL+"/organizations/"+globalid+"/dns/"+dnsname+qsParam, nil)
if er... | func (act *Record) Delete() {
for reply, index, records := struct {
Status Status `json:"status"`
}{}, 0, act.ListRecords(); index < len(records); index++ {
body := act.NewRequestBody(map[string]string{"record_id": records[index]}, "ttl", "sub_domain").GetReader()
if exitIfErr(request(http.MethodPost, actions.D... | func (digioceandns *Digioceandns) Deletedns(request interface{}) (resp interface{}, err error) {
return resp, err
} | func (s *DomainsService) Delete(ID int) (*Response, error) {
path := domainAction("Remove")
returnedDomain := domainWrapper{}
payload := newPayLoad(s.client.CommonParams)
payload.Set("domain_id", strconv.FormatInt(int64(ID), 10))
res, err := s.client.post(path, payload, &returnedDomain)
if err != nil {
return... | func (o *ClusterUninstaller) deleteCISDNSRecord(item cloudResource) error {
o.Logger.Debugf("Deleting DNS record %q", item.name)
ctx, cancel := o.contextWithTimeout()
defer cancel()
options := o.dnsRecordsSvc.NewDeleteDnsRecordOptions(item.id)
_, details, err := o.dnsRecordsSvc.DeleteDnsRecordWithContext(ctx, opt... | func (probe *Probe) deleteDomain(d domain) {
domainNode := probe.getDomain(d)
if domainNode != nil {
probe.Ctx.Graph.Lock()
defer probe.Ctx.Graph.Unlock()
if err := probe.Ctx.Graph.DelNode(domainNode); err != nil {
probe.Ctx.Logger.Error(err)
}
}
} | func (c *DNSProvider) CleanUp(domain, fqdn, value string) error {
zone, err := c.getHostedZone(fqdn)
if err != nil {
return err
}
records, err := c.findTxtRecords(zone, fqdn, value)
if err != nil {
return err
}
for _, rec := range records {
change := &dns.Change{
Deletions: []*dns.ResourceRecordSet{re... | func (c *Client) DeleteRecordByDomain(domainID interface{}, ID int) error {
var DOResp struct {
Status Status `json:"status"`
Message string `json:"message"`
}
err := c.doGet(fmt.Sprintf("/domains/%v/records/%d/destroy", domainID, ID), &DOResp)
if err != nil {
return err
}
if DOResp.Status == StatusError... | func (c *Client) LdapServerDelete(r string) ( error) {
var err error
return err
} | func (ctx acrnContext) Delete(domainName string, domainID int) error {
return nil
} | func (dns *awsRoute53) UnregisterDomain(orgId uint, domain string) error {
log := loggerWithFields(logrus.Fields{"organisationId": orgId, "domain": domain})
log.Info("unregistering domain")
state := &domainState{}
found, err := dns.stateStore.find(orgId, domain, state)
if err != nil {
log.Errorf("querying stat... | func (nameservers *NameServers) Delete(ctx context.Context, domain, id string) (err error) {
response, err := httpDo(ctx, nameservers.Options, "DELETE", apiURL("/domain/%s/nameServer/%s", domain, id), nil)
if err != nil {
return
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return un... | func resourceRage4RecordDelete(d *schema.ResourceData, meta interface{}) error {
// get which domain we're working on
recordId, err := strconv.Atoi(d.Id())
if (err != nil) {
return fmt.Errorf("Failed to get Rage4 record id: %s", err)
}
domain := d.Get("domain")
log.Printf("[INFO] Deleting Rage4 Record... | func (a *API) DeleteRecord(subName, domainName, rtype, content string) (RRSets, error) {
// Check if RRSet actually exists
rrsets, err := a.GetRRSets(subName, domainName, rtype)
if err != nil {
return nil, err
}
if len(rrsets) > 0 {
// Quote content if record type is TXT
if rtype == "TXT" {
content = "\""... | func RecordDelete(d *schema.ResourceData, meta interface{}) error {
client := meta.(*ns1.Client)
_, err := client.Records.Delete(d.Get("zone").(string), d.Get("domain").(string), d.Get("type").(string))
d.SetId("")
return err
} | func DeleteAlias(c *Config, address string) error {
body := fmt.Sprintf("address=%s", address)
return exeAlias(c, "remove", body)
} | func Delete(domainName []byte) bool {
message := "DeleteDomain: " + string(domainName)
runtime.Log(message)
owner := storage.Get(ctx, domainName)
if owner == nil {
runtime.Log("Domain is not yet registered")
return false
}
if !runtime.CheckWitness(owner.([]byte)) {
runtime.Log("Sender is not the owner, ca... | func (m *Server) handleDomainsDeleteDomain() http.HandlerFunc {
return func(w http.ResponseWriter, req *http.Request) {
logrus.Info("Delete domain")
// Extract URI variables
domain := mux.Vars(req)["domain"]
// Create forward in database
err := m.DB.DeleteDomain(domain)
if err != nil {
// Forward alre... | func (c *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _, _ := acme.DNS01Record(domain, keyAuth)
records, err := c.getRecords(domain)
if err != nil {
return err
}
for _, rec := range records {
if rec.Fqdn == fqdn && rec.Type == "TXT" {
request := &namecom.DeleteRecordRequest{
Domai... | func (o *ClusterUninstaller) deleteDNSSvcDNSRecord(item cloudResource) error {
o.Logger.Debugf("Deleting DNS record %q", item.name)
ctx, cancel := o.contextWithTimeout()
defer cancel()
options := o.dnsServicesSvc.NewDeleteResourceRecordOptions(o.DNSInstanceID, o.zoneID, item.id)
details, err := o.dnsServicesSvc.D... | func (s *TxtRecordService) Delete(ctx context.Context, domainID, recordID int64) (*SuccessMessage, error) {
endpoint, err := s.client.createEndpoint(defaultVersion, "domains", strconv.FormatInt(domainID, 10), "records", "txt", strconv.FormatInt(recordID, 10))
if err != nil {
return nil, fmt.Errorf("failed to create... | func (c *Client) DeleteRecord(domainID, recordID int) error {
uri := fmt.Sprintf("/%d/records/%d", domainID, recordID)
req, err := c.newRequest(http.MethodDelete, uri, nil)
if err != nil {
return err
}
_, err = c.do(req, nil)
return err
} | func (o *DNSOp) Delete(ctx context.Context, id types.ID) error {
_, err := o.Read(ctx, id)
if err != nil {
return err
}
ds().Delete(o.key, sacloud.APIDefaultZone, id)
return nil
} | func removeOtherNS(dc *models.DomainConfig) {
newList := make([]*models.RecordConfig, 0, len(dc.Records))
for _, rec := range dc.Records {
if rec.Type == "NS" {
// apex NS inside dnsimple are expected.
if rec.GetLabelFQDN() == dc.Name && strings.HasSuffix(rec.GetTargetField(), ".dnsimple.com.") {
continue... | func (c DomainsClient) Delete(domainName string) ClientError {
return c.client.NewRequest("DELETE", fmt.Sprintf("%s/%s", domainsEndpoint, domainName), nil, nil, nil)
} | func (mmc *MemCache) Delete(domain string) error {
mmc.cl.Lock()
defer mmc.cl.Unlock()
if mmc.certs == nil {
return notExists{err: errors.New("not found")}
}
delete(mmc.certs, domain)
return nil
} | func (c *Client) NamespaceDelete(r string) ( error) {
var err error
return err
} | func (c *Client) DeleteRecord(ctx context.Context, record *DNSRecord) error {
endpoint := c.baseURL.JoinPath("v1", "zones", strconv.Itoa(record.ZoneID), "records", strconv.Itoa(record.ID))
req, err := newJSONRequest(ctx, http.MethodDelete, endpoint, record)
if err != nil {
return err
}
err = c.do(req, nil)
if... | func (probe *Probe) deleteDomain(d *libvirtgo.Domain) {
domainNode := probe.getDomain(d)
if domainNode != nil {
probe.graph.Lock()
defer probe.graph.Unlock()
if err := probe.graph.DelNode(domainNode); err != nil {
logging.GetLogger().Error(err)
}
}
} | func Test_DeleteSubdomain_ValidParameters_SubdomainNotFound_ErrorIsReturned(t *testing.T) {
// arrange
domain := "example.com"
subdomain := "www"
recordType := "AAAA"
infoProvider := &testDNSInfoProvider{
getSubdomainRecordFunc: func(domain, subdomain, recordType string) (record dnsimple.Record, err error) {
... | func (c *DnsimpleApi) deleteRecordFunc(recordID int, domainName string) func() error {
return func() error {
client := c.getClient()
accountID, err := c.getAccountID()
if err != nil {
return err
}
_, err = client.Zones.DeleteRecord(accountID, domainName, recordID)
if err != nil {
return err
}
... | func (c *DNSProvider) CleanUp(domain, fqdn, value string) error {
z, err := c.getHostedZoneName(fqdn)
if err != nil {
klog.Infof("Error getting hosted zone name for: %s, %v", fqdn, err)
return err
}
_, err = c.recordClient.Delete(
context.TODO(),
c.resourceGroupName,
z,
c.trimFqdn(fqdn),
dns.TXT, "")... | func (c *DNSProvider) CleanUp(domain, fqdn, value string) error {
z, err := c.getHostedZoneName(fqdn)
if err != nil {
c.log.Error(err, "Error getting hosted zone name for:", fqdn)
return err
}
_, err = c.recordClient.Delete(
context.TODO(),
c.resourceGroupName,
z,
c.trimFqdn(fqdn, z),
dns.TXT, "")
... | func (vega *VegaDNSClient) DeleteRecord(recordID int) error {
resp, err := vega.Send("DELETE", fmt.Sprintf("records/%d", recordID), nil)
if err != nil {
return fmt.Errorf("Send DELETE error in DeleteTXT: %s", err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Erro... | func (s *ChallSrv) DeleteDNSOneChallenge(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
delete(s.dnsOne, host)
} | func DeleteRecord(c *pdns.Client, Zone string, Name string, Type string) (string, error) {
if exists, err := c.RecordExists(Zone, Name, Type); exists != true {
return "record Dosen't exists: " + Name, err
}
err := c.DeleteRecordSet(Zone, Name, Type)
if err != nil {
return "Error Deleting Record: " + Name, err
... | func (c *Cache) RecordTypeRemove(domainName string, record Record, queryType string) {
searchDomain := strings.ToLower(domainName)
recordToLower(&record)
c.createTree(searchDomain, record.Type)
c.Lock()
defer c.Unlock()
removeID := -1
for id, oldrecord := range c.Domain[searchDomain].QueryType[record.Type].Host... | func DeleteDomainMocked(t *testing.T, domainIn *types.Domain) {
assert := assert.New(t)
// wire up
cs := &utils.MockConcertoService{}
ds, err := NewDomainService(cs)
assert.Nil(err, "Couldn't load domain service")
assert.NotNil(ds, "Domain service not instanced")
// to json
dIn, err := json.Marshal(domainIn)... | func (c *Nat) Delete(vsys, base string, e ...interface{}) error {
var err error
if len(e) == 0 {
return nil
}
names := make([]string, len(e))
for i := range e {
switch v := e[i].(type) {
case string:
names[i] = v
case Entry:
names[i] = v.Name... | func (c *ovhProvider) deleteRecordFunc(id int64, fqdn string) func() error {
return func() error {
err := c.client.CallAPI("DELETE", fmt.Sprintf("/domain/zone/%s/record/%d", fqdn, id), nil, nil, true)
if err != nil {
return err
}
return nil
}
} | func ExampleDomain_removeWww() {
fmt.Println(Domain("https://www.Example.COM/?param=value", false, true))
// Output: example.com <nil>
} | func (d *DomainServiceHandler) Delete(ctx context.Context, domain string) error {
req, err := d.client.NewRequest(ctx, http.MethodDelete, fmt.Sprintf("%s/%s", domainPath, domain), nil)
if err != nil {
return err
}
return d.client.DoWithContext(ctx, req, nil)
} | func (c *Client) DeleteDNSRecords(dnsNames []string, logger logrus.FieldLogger) error {
zoneNameList := c.aws.GetPublicHostedZoneNames()
if len(zoneNameList) == 0 {
return errors.New("no public hosted zones names found from AWS")
}
for _, dnsName := range dnsNames {
// Fetch the zone name for that customer DNS... | func (e *DNSExtension) DeleteA(arg SetAArgs, result *ArbitrarySuccessResult) error {
var serviceName string
var ok bool
if serviceName, ok = checkAuth(arg.APIKey); ok {
logging.Info("rpc", "["+serviceName+"] DeleteA("+arg.Domain+")")
} else {
logging.Warning("rpc", "Invalid auth for DeleteA("+arg.Domain+")")
... | func (provider *DNSProvider) CleanUp(domain, token, keyAuth string) error {
fqdn, _, _ := acme.DNS01Record(domain, keyAuth)
provider.recordIDsMu.Lock()
recordID, ok := provider.recordIDs[fqdn]
provider.recordIDsMu.Unlock()
if !ok {
return fmt.Errorf("unknown recordID for %q", fqdn)
}
authZone, err := acme.F... | func (c *Client) StaticHostAddressDelete(r string) ( error) {
var err error
return err
} | func (p *Provider) deleteRecord(ctx context.Context, zone string, record libdns.Record) (libdns.Record, error) {
p.client.mutex.Lock()
defer p.client.mutex.Unlock()
recordType, err := convertStringToRecordType(record.Type)
if err != nil {
return record, err
}
_, err = p.client.azureClient.Delete(
ctx,
p.R... | func DeleteDomainRecordMocked(t *testing.T, dr *types.DomainRecord) {
assert := assert.New(t)
// wire up
cs := &utils.MockConcertoService{}
ds, err := NewDomainService(cs)
assert.Nil(err, "Couldn't load domain service")
assert.NotNil(ds, "Domain service not instanced")
// to json
drIn, err := json.Marshal(dr... | func (s *NameserverService) DeleteRecord(recID int) error {
req := s.client.NewRequest(methodNameserverDeleteRecord, map[string]interface{}{
"id": recID,
})
_, err := s.client.Do(*req)
if err != nil {
return err
}
return nil
} | func (p *Parser) RemoveDomainFromHostMapping(domain string) error {
exists, ip, dIndex := p.isDomainExists(domain)
if !exists {
return errors.New(fmt.Sprintf("%s doesn't exists", domain))
}
mapping := p.parsedContent[ip]
if len(mapping) == 1 {
err := p.RemoveHostMapping(ip)
if err != nil {
return err
}
... | func (client *Client) DeleteDomainWithOptions(request *DeleteDomainRequest, runtime *util.RuntimeOptions) (_result *DeleteDomainResponse, _err error) {
_err = util.ValidateModel(request)
if _err != nil {
return _result, _err
}
query := map[string]interface{}{}
if !tea.BoolValue(util.IsUnset(request.DomainName)) ... | func SirenDelete(id int64) error {
if id == 0 {
return nil
}
_, err := pool.Exec(context.Background(), `
DELETE FROM
sirens
WHERE
id = $1
`, id)
if err != nil {
errmsg("DeleteSiren Exec", err)
}
return err
} | func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
info := dns01.GetChallengeInfo(domain, keyAuth)
zone, err := getZone(info.EffectiveFQDN)
if err != nil {
return fmt.Errorf("edgedns: %w", err)
}
existingRec, err := configdns.GetRecord(zone, info.EffectiveFQDN, "TXT")
if err != nil {
if is... | func PbrNATDel(prefix string) error {
log.Debugf("PbrNATDel(%s)\n", prefix)
return nil
} | func UA_FindServersOnNetworkRequest_delete(p []UA_FindServersOnNetworkRequest) {
UA_delete(p, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[37]))[:])
} | func (d *DNSProvider) CleanUp(domain, token, keyAuth string) error {
info := dns01.GetChallengeInfo(domain, keyAuth)
rootDomain, subDomain, err := splitDomain(info.EffectiveFQDN)
if err != nil {
return fmt.Errorf("yandex: %w", err)
}
ctx := context.Background()
records, err := d.client.GetRecords(ctx, rootDo... | func UA_FindServersOnNetworkResponse_delete(p []UA_FindServersOnNetworkResponse) {
UA_delete(p, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[89]))[:])
} | func (g *LiveDNS) DeleteAllDomainRecords(fqdn string) (err error) {
_, err = g.client.Delete("domains/"+fqdn+"/records", nil, nil)
return
} | func (pr *RouteDomainResource) Delete(id string) error {
if err := pr.c.ModQuery("DELETE", BasePath+RouteDomainEndpoint+"/"+id, nil); err != nil {
return err
}
return nil
} | func (nc *NetserviceCli) DeleteHost(host string, ips []string) error {
if len(nc.netSvrs) == 0 {
return fmt.Errorf("no available bcs-netservice")
}
if len(host) == 0 {
return fmt.Errorf("bad request host ip")
}
seq := nc.random.Perm(len(nc.netSvrs))
httpClient, prefix := nc.getHTTPClient(nc.httpClientTimeout)... | func (c *Client) NetworkDSPTestDelete(r string) ( error) {
var err error
return err
} | func (s *ChallSrv) DeleteDNSServFailRecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.servFailRecords, host)
} | func (client DataLabelingClient) deleteRecord(ctx context.Context, request common.OCIRequest, binaryReqBody *common.OCIReadSeekCloser, extraHeaders map[string]string) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodDelete, "/records/{recordId}", binaryReqBody, extraHeaders)
if err !=... | func NDBDelete(db *nutsdb.DB, bucket string, key []byte) error {
nerr := db.Update(func(tx *nutsdb.Tx) error {
err := tx.Delete(bucket, key)
if err != nil {
return err
}
return nil
})
if nerr != nil {
return nerr
}
return nil
} | func (handler *DnsHandler) ZoneDelete(zone string) error {
return nil
} | func ZoneRecordDelete(c eurodnsgo.Client, z Zone, r Record) error {
return nil
} | func HandleDeleteDomainSuccessfully(t *testing.T) {
th.Mux.HandleFunc("/domains/9fe1d3", func(w http.ResponseWriter, r *http.Request) {
th.TestMethod(t, r, "DELETE")
th.TestHeader(t, r, "X-Auth-Token", client.TokenID)
w.WriteHeader(http.StatusNoContent)
})
} | [
"0.73349965",
"0.72168624",
"0.66457784",
"0.6630911",
"0.65485066",
"0.6537258",
"0.65104294",
"0.6501692",
"0.64412254",
"0.64364755",
"0.64296883",
"0.62857825",
"0.6226502",
"0.620469",
"0.618871",
"0.6174125",
"0.6111059",
"0.61061543",
"0.60670036",
"0.605098",
"0.60365... |
Delete NS record by its name | func deleteNsByName(name string, payload *strings.Reader, c Config) {
nsID := GetIdByName(name, c)
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + strconv.Itoa(nsID) + ""
send(url, DELETE, payload, c)
if filepath.Base(url) == "0" {
fmt.Println("Error: Wrong id -> ", url)
} else {
fmt.Println("Domai... | func (iClient *IBloxClient) DeleteCNAMERecord(name, ipAddr, netview, cidr string) {
obj := ibclient.NewRecordCNAME(
ibclient.RecordCNAME{
Name: name,
View: netview,
Ea: iClient.ea,
},
)
res, err := iClient.getCNAMERecord(obj)
// If error or record doesn't exist, return
if err != nil || res == nil ||... | func deleteNsById(nsID string, payload *strings.Reader, c Config) {
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + nsID
send(url, DELETE, payload, c)
if filepath.Base(url) == "0" {
fmt.Println("Error: Wrong id -> ", url)
} else {
fmt.Println("Domain record deleted successfully ", url)
}
} | func (client Client) DeleteNamed(ctx context.Context, kind string, name string, parent *datastore.Key) error {
key := datastore.NameKey(kind, name, parent)
err := client.ds.Delete(ctx, key)
if err != nil {
return errors.Wrap(err, "failed to delete named datastore entity")
}
return nil
} | func (act *Record) Delete() {
for reply, index, records := struct {
Status Status `json:"status"`
}{}, 0, act.ListRecords(); index < len(records); index++ {
body := act.NewRequestBody(map[string]string{"record_id": records[index]}, "ttl", "sub_domain").GetReader()
if exitIfErr(request(http.MethodPost, actions.D... | func (s *NameserverService) DeleteRecord(recID int) error {
req := s.client.NewRequest(methodNameserverDeleteRecord, map[string]interface{}{
"id": recID,
})
_, err := s.client.Do(*req)
if err != nil {
return err
}
return nil
} | func (client DataLabelingClient) deleteRecord(ctx context.Context, request common.OCIRequest, binaryReqBody *common.OCIReadSeekCloser, extraHeaders map[string]string) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodDelete, "/records/{recordId}", binaryReqBody, extraHeaders)
if err !=... | func deleteRecord(stub shim.ChaincodeStubInterface, args []string) peer.Response {
if len(args) != 2 {
return shim.Error(errorIncorrectParamNum + " Expecting 2")
}
fmt.Println("args=", args)
objectName := args[0]
if objectName == "" {
return shim.Error(errorMissParam + " Expect object name")
}
keywords := ... | func (s *ChallSrv) DeleteDNSCNAMERecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.cnameRecords, host)
} | func (cass *CassandraIndexer) Delete(name *repr.StatName) (err error) {
cass.RamIndexer.Delete(name)
mLen := len(strings.Split(name.Key, "."))
cassQ := fmt.Sprintf(
"DELETE FROM %s WHERE segment={pos: ?, segment: ?} AND has_data=1 AND length=? AND id=?",
cass.db.PathTable(),
)
// Paths table
err = cass.conn... | func RecordDelete(d *schema.ResourceData, meta interface{}) error {
client := meta.(*ns1.Client)
_, err := client.Records.Delete(d.Get("zone").(string), d.Get("domain").(string), d.Get("type").(string))
d.SetId("")
return err
} | func DeleteArecord() {
dbService := db.NewDbService(os.Getenv("MICRO_API_TOKEN"))
rsp, err := dbService.Delete(&db.DeleteRequest{
Id: "1",
Table: "users",
})
fmt.Println(rsp, err)
} | func (api *API) Del(name string) error {
nameP := -1
for i, item := range api.cfg.Qitmeerds {
if item.Name == name {
nameP = i
break
}
}
if nameP == -1 {
return nil
}
api.cfg.Qitmeerds = append(api.cfg.Qitmeerds[:nameP], api.cfg.Qitmeerds[nameP+1:]...)
api.cfg.Save(api.cfg.ConfigFile)
return nil
} | func DeleteRecord(c *pdns.Client, Zone string, Name string, Type string) (string, error) {
if exists, err := c.RecordExists(Zone, Name, Type); exists != true {
return "record Dosen't exists: " + Name, err
}
err := c.DeleteRecordSet(Zone, Name, Type)
if err != nil {
return "Error Deleting Record: " + Name, err
... | func (s *Session) TXTDelete(zone, fqdn string) error {
log.Printf("Delete TXT records with zone=%s and fqdn=%s", zone, fqdn)
var c http.Client
req, err := http.NewRequest(http.MethodDelete,
URI+"/REST/TXTRecord/"+zone+"/"+fqdn+"/", nil)
if err != nil {
return err
}
req.Header = s.authHeader
resp, err := c.D... | func resourceRage4RecordDelete(d *schema.ResourceData, meta interface{}) error {
// get which domain we're working on
recordId, err := strconv.Atoi(d.Id())
if (err != nil) {
return fmt.Errorf("Failed to get Rage4 record id: %s", err)
}
domain := d.Get("domain")
log.Printf("[INFO] Deleting Rage4 Record... | func DeleteResource(name string) error {
var err error
r := Resource{}
queryResult := dbClient.Where("name = ?", name).First(&r)
if queryResult.RowsAffected == 0 {
return nil
}
if err = dbClient.Unscoped().Delete(&r).Error; err != nil {
klog.Errorf("failed to delete resource(name=%s): %v", name, err)
re... | func deleteRecord(c echo.Context) error {
id, _ := strconv.Atoi(c.Param("id"))
delete(records, id)
return c.NoContent(http.StatusNoContent)
} | func (h *History) Delete(filename string) {
delete(h.records, filename)
} | func (iClient *IBloxClient) DeleteARecord(name, ipAddr, netview, cidr string) {
obj := ibclient.NewRecordA(
ibclient.RecordA{
Name: name,
Ipv4Addr: ipAddr,
View: netview,
Ea: iClient.ea,
},
)
res, err := iClient.getARecord(obj)
if err != nil {
return
}
// If record doesn't exist, r... | func (c *Client) DeleteRecord(ctx context.Context, domain string, id int) error {
endpoint, err := c.BaseURL.Parse(path.Join(c.BaseURL.Path, "dns", "delete", domain, strconv.Itoa(id)))
if err != nil {
return fmt.Errorf("failed to parse endpoint: %w", err)
}
respBody, err := c.do(ctx, endpoint, nil)
if err != ni... | func (ns *Netstorage) Delete(nsPath string) (*http.Response, string, error) {
return ns._request(map[string]string{
"action": "delete",
"method": "POST",
"path": nsPath,
})
} | func (s *server) Delete(ctx context.Context, body *pb.NameHolder) (*pb.DeletionResponse, error) {
appName := body.GetName()
filter := types.M{
mongo.NameKey: appName,
mongo.InstanceTypeKey: mongo.AppInstance,
}
node, _ := redis.FetchAppNode(appName)
go redis.DecrementServiceLoad(ServiceName, node)
go... | func deleteRecord(c *godo.Client, zoneName string, recordID int) error {
resp, err := c.Domains.DeleteRecord(context.TODO(), zoneName, recordID)
if err != nil {
return fmt.Errorf("error applying changeset: %v", err)
}
if err = handleResponse(resp); err != nil {
return err
}
return nil
} | func Delete(context interface{}, db *db.DB, name string) error {
log.Dev(context, "Delete", "Started : Name[%s]", name)
set, err := GetByName(context, db, name)
if err != nil {
return err
}
f := func(c *mgo.Collection) error {
q := bson.M{"name": set.Name}
log.Dev(context, "Delete", "MGO : db.%s.remove(%s)... | func (n *GoName) DeleteDNSRecord(domain, recordID string) (data BasicResponse, err error) {
req := []byte(fmt.Sprintf(`{"record_id":"%s"}`, recordID))
err = n.post(fmt.Sprintf("/api/dns/delete/%s", domain), req, &data)
if data.Result.Failed() {
return data, fmt.Errorf("api error: %s", data.Result.String())
}
re... | func (r *Record) Delete(client *godo.Client) error {
_, err := client.Domains.DeleteRecord(context.TODO(), r.zoneName.String(""), r.ID)
return err
} | func (s *TxtRecordService) Delete(ctx context.Context, domainID, recordID int64) (*SuccessMessage, error) {
endpoint, err := s.client.createEndpoint(defaultVersion, "domains", strconv.FormatInt(domainID, 10), "records", "txt", strconv.FormatInt(recordID, 10))
if err != nil {
return nil, fmt.Errorf("failed to create... | func (g *LiveDNS) DeleteDomainRecordsByName(fqdn, name string) (err error) {
_, err = g.client.Delete("domains/"+fqdn+"/records/"+name, nil, nil)
return
} | func deleteNsByValue(value string, payload *strings.Reader, c Config) {
var validValue = value
var nsID = 0
if !strings.HasSuffix(".", value) {
validValue += "."
nsID = GetId(validValue, c)
} else {
nsID = GetId(value, c)
}
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + strconv.Itoa(nsID) + ""
... | func (dbobj PGSQLDB) DeleteRecord(t Tbl, keyName string, keyValue string) (int64, error) {
tbl := GetTable(t)
return dbobj.DeleteRecordInTable(tbl, keyName, keyValue)
} | func deleteRecordset(records []*models.RecordConfig, zonename string) error {
akaRecord, err := rcToRs(records, zonename)
if err != nil {
return err
}
err = akaRecord.Delete(zonename, true)
if err != nil {
if dnsv2.IsConfigDNSError(err) && err.(dnsv2.ConfigDNSError).NotFound() {
return fmt.Errorf("recordse... | func (d *DeviceClient) DeleteByName(name string) error {
req, err := http.NewRequest("DELETE", d.url+"/name/"+url.QueryEscape(name), nil)
if err != nil {
fmt.Println(err)
return err
}
resp, err := makeRequest(req)
if err != nil {
fmt.Println(err)
return err
}
if resp == nil {
fmt.Println(ErrResponseNi... | func deleteRecord(t *testing.T, dbo *sql.DB) {
// delete the record with id 1
exec(t, dbo, "DELETE FROM "+tableName+" WHERE id = ?;", testingID)
data := selectWhere(t, dbo, "id = ?", testingID)
assert.Equal(t, 0, len(data))
} | func (t *store) Delete(
ctx context.Context,
key string,
out runtime.Object,
preconditions *storage.Preconditions,
) error {
ns, name, err := t.decodeKey(key)
if err != nil {
glog.Errorf("decoding key %s (%s)", key, err)
return err
}
req := t.cl.Delete().AbsPath(
"apis",
groupName,
tprVersion,
"nam... | func (s *ChallSrv) DeleteDNSARecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.aRecords, host)
} | func (t *SimpleChaincode) Delete(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
record := args[0]
err := stub.DelState(record) //remove the key from chaincode state
if err != nil {
return nil, errors... | func (vega *VegaDNSClient) DeleteRecord(recordID int) error {
resp, err := vega.Send("DELETE", fmt.Sprintf("records/%d", recordID), nil)
if err != nil {
return fmt.Errorf("Send DELETE error in DeleteTXT: %s", err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Erro... | func (api *API) DeleteDNSRecord(zone, id string) error {
z, err := api.ListZones(zone)
if err != nil {
return err
}
// TODO(jamesog): This is brittle, fix it
zid := z[0].ID
uri := "/zones/" + zid + "/dns_records/" + id
res, err := api.makeRequest("DELETE", uri, nil)
if err != nil {
fmt.Println("Error with m... | func Delete(namespace, key string) {
key = formKey(namespace, key)
m.delete(key)
} | func (r *REST) Delete(ctx api.Context, name string) (runtime.Object, error) {
return r.store.Delete(ctx, name)
} | func (n *NatsBackend) deleteRecord(k KV) *ResponseMessage {
err := n.DeleteRecord(k)
if err != nil && err == nats.ErrKeyNotFound {
return &ResponseMessage{
Code: 404,
Error: "key not found",
}
}
if err != nil && err != nats.ErrKeyNotFound {
return &ResponseMessage{
Code: 500,
Error: "internal s... | func (instance *Instance) Delete(name string) error {
if res, err := instance.DB.Exec(`DELETE FROM metadata WHERE name = ?;`, name); err != nil {
panic(fmt.Errorf("metadb: failed to delete entry for '%s':\n%s", name, err))
} else if affected, err := res.RowsAffected(); err != nil {
return nil
} else if affected ... | func DeleteRecord(c *gin.Context) {
var record models.Record
if err := models.DB.Where("id = ?", c.Param("id")).First(&record).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
var files []models.File
models.DB.Where("record_id = ?", record.ID).Find(&files)
if mo... | func (a *actuator) Delete(ctx context.Context, log logr.Logger, dns *extensionsv1alpha1.DNSRecord, _ *extensionscontroller.Cluster) error {
// Create AWS client
credentials, err := aws.GetCredentialsFromSecretRef(ctx, a.client, dns.Spec.SecretRef, true)
if err != nil {
return fmt.Errorf("could not get AWS credenti... | func (verber *ResourceVerber) Delete(kind string, namespace string, name string) error {
apiPath, ok := kindToAPIPathMapping[kind]
if !ok {
return errors.New(fmt.Sprintf("Unknown resource kind: %s", kind))
}
return verber.client.Delete().
Namespace(namespace).
Resource(apiPath).
Name(name).
Do().
Error... | func (client *HTTPPolicySetClient) DeleteByName(name string) error {
res, err := client.GetByName(name)
if err != nil {
return err
}
return client.Delete(res.UUID)
} | func (a *API) DeleteRecord(subName, domainName, rtype, content string) (RRSets, error) {
// Check if RRSet actually exists
rrsets, err := a.GetRRSets(subName, domainName, rtype)
if err != nil {
return nil, err
}
if len(rrsets) > 0 {
// Quote content if record type is TXT
if rtype == "TXT" {
content = "\""... | func (p *Provider) deleteRecord(ctx context.Context, zone string, record libdns.Record) (libdns.Record, error) {
p.client.mutex.Lock()
defer p.client.mutex.Unlock()
recordType, err := convertStringToRecordType(record.Type)
if err != nil {
return record, err
}
_, err = p.client.azureClient.Delete(
ctx,
p.R... | func (c *Nat) Delete(vsys, base string, e ...interface{}) error {
var err error
if len(e) == 0 {
return nil
}
names := make([]string, len(e))
for i := range e {
switch v := e[i].(type) {
case string:
names[i] = v
case Entry:
names[i] = v.Name... | func (t *Timetrace) DeleteRecord(record Record) error {
path := t.fs.RecordFilepath(record.Start)
if _, err := os.Stat(path); os.IsNotExist(err) {
return ErrRecordNotFound
}
return os.Remove(path)
} | func Delete(namespace string, dev *model.Dev) error {
fullName := getFullName(namespace, dev)
return deleteEntry(fullName)
} | func DeleteRecord(id uuid.UUID) error {
return Delete([]byte(RecordsBucket), []byte(id.String()))
} | func (objMgr *ObjectManager) DeleteARecord(recA RecordA) (string, error) {
var res []RecordA
recordName := NewRecordA(recA)
if len(recA.Ref) > 0 {
return objMgr.connector.DeleteObject(recA.Ref)
} else {
err := objMgr.connector.GetObject(recordName, "", &res)
if err != nil || res == nil || len(res) == 0 {
... | func deleteDR(name string, c *Controller) {
err := c.clientset.NdmV1alpha1().Disks().Delete(name, &metav1.DeleteOptions{})
if err != nil {
glog.Info("Unable to delete disk object from etcd : ", err)
} else {
glog.Info("Deleted disk object from etcd : ", name)
}
} | func (c Claims) Del(name string) { delete(c, name) } | func (i *IdentityStore) pathEntityNameDelete() framework.OperationFunc {
return func(ctx context.Context, req *logical.Request, d *framework.FieldData) (*logical.Response, error) {
entityName := d.Get("name").(string)
if entityName == "" {
return logical.ErrorResponse("missing entity name"), nil
}
i.lock.L... | func (c *Client) DeleteRecord(ctx context.Context, record *DNSRecord) error {
endpoint := c.baseURL.JoinPath("v1", "zones", strconv.Itoa(record.ZoneID), "records", strconv.Itoa(record.ID))
req, err := newJSONRequest(ctx, http.MethodDelete, endpoint, record)
if err != nil {
return err
}
err = c.do(req, nil)
if... | func Delete(w http.ResponseWriter, r *http.Request) {
db := dbConn()
// Get the URL `?id=X` parameter
nId := r.URL.Query().Get("id")
// Prepare the SQL Delete
delForm, err := db.Prepare("DELETE FROM names WHERE id=?")
if err != nil {
panic(err.Error())
}
// Execute the Delete SQL
delForm.Exec(nId)
// S... | func UA_QualifiedName_delete(p []UA_QualifiedName) {
UA_delete(p, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[19]))[:])
} | func (c *Cache) RemoveRecord(domainName string, record Record) {
searchDomain := strings.ToLower(domainName)
recordToLower(&record)
c.createTree(searchDomain, record.Type)
c.Lock()
defer c.Unlock()
removeID := -1
for id, oldrecord := range c.Domain[searchDomain].QueryType[record.Type].HostRecord[record.Name] {
... | func (n *Namespace) Delete(names, path []string) error {
n.con.LogAction("(delete) %s: %v", n.Plural, names)
if len(names) == 0 {
return nil
}
_, err := n.con.Delete(path, nil, nil)
return err
} | func (r *Repo) Delete(ctx context.Context, named repository.Named, id string) error {
var oid, err = primitive.ObjectIDFromHex(id)
var res *mongo.DeleteResult
if err == nil {
res, err = r.db.Collection(named.Name()).DeleteOne(ctx, bson.M{"_id": oid})
}
if err == nil && res.DeletedCount == 0 {
err = repositor... | func (s *RecordsService) Delete(domain string, recordID string) (*Response, error) {
payload := s.client.CommonParams.toPayLoad()
payload.Add("domain_id", domain)
payload.Add("record_id", recordID)
returnedRecord := recordWrapper{}
res, err := s.client.post(methodRecordRemove, payload, &returnedRecord)
if err !... | func (c *Client) DeleteDNSRecord(r *DNSRecord) (*SimpleResponse, error) {
if len(r.ID) == 0 {
err := fmt.Errorf("ID is empty")
return nil, IDisEmptyError.wrap(err)
}
if len(r.DNSDomainID) == 0 {
err := fmt.Errorf("DNSDomainID is empty")
return nil, IDisEmptyError.wrap(err)
}
url := fmt.Sprintf("/v2/dns/%... | func (c Client) DeleteRecord(ctx context.Context, zoneID, recordID string) error {
endpoint := c.baseURL.JoinPath("user", "v1", "zones", zoneID, "records", recordID)
req, err := newJSONRequest(ctx, http.MethodDelete, endpoint, nil)
if err != nil {
return fmt.Errorf("create request: %w", err)
}
return c.do(req,... | func (client *NetworkSecurityPolicyClient) DeleteByName(name string) error {
res, err := client.GetByName(name)
if err != nil {
return err
}
return client.Delete(res.UUID)
} | func DeleteAsn(w http.ResponseWriter, req *http.Request) {
db, err := myconfig.GetMysqlConnect()
id := req.FormValue("id")
db.Exec("DELETE FROM sim_asn WHERE id = " + id)
helper.CheckErr(err)
http.Redirect(w, req, "/", http.StatusSeeOther)
} | func (a *EvaluationRepository) DeleteGroupByName(name string) {
q := model.Question{
Module: name,
}
_, err := a.conn.NamedQuery(`DELETE FROM questions WHERE module = :module`, q)
if err != nil {
fmt.Println("ERROR DeleteGroupByName ", err)
}
} | func (s *Store) DeleteRecord(id string) error {
return s.Records.Delete(
[]byte(id),
)
} | func (s *service) Delete(resourceName string) apperrors.AppError {
err := s.repository.DeleteDenier(resourceName)
if err != nil {
return err
}
err = s.repository.DeleteCheckNothing(resourceName)
if err != nil {
return err
}
err = s.repository.DeleteRule(resourceName)
if err != nil {
return err
}
retu... | func (dbobj PGSQLDB) DeleteRecordInTable(table string, keyName string, keyValue string) (int64, error) {
q := "delete from " + table + " WHERE " + dbobj.escapeName(keyName) + "=$1"
fmt.Printf("q: %s\n", q)
tx, err := dbobj.db.Begin()
if err != nil {
return 0, err
}
defer tx.Rollback()
result, err := tx.Exec(q... | func (d DB) Delete(string) error { return errors.New("stub") } | func (*server) Delete(ctx context.Context, req *model.DeleteReq) (*model.DeleteResp, error) {
ID := req.GetId()
blogID, err := primitive.ObjectIDFromHex(ID)
log.Printf("Req => %v\n", req)
if err != nil {
errMsg := status.Errorf(codes.InvalidArgument, "Failed read ID")
return nil, errMsg
}
data := &dataItem... | func (o *ClusterUninstaller) deleteDNSRecord(item cloudResource) error {
if len(o.CISInstanceCRN) > 0 {
return o.deleteCISDNSRecord(item)
}
return o.deleteDNSSvcDNSRecord(item)
} | func (db *Database) Del(id, rev string) (string, error) {
resp, err := db.conn.request("DELETE", queryURL(
db.Name, id) + fmt.Sprintf("?rev=%s", rev), nil, nil, db.auth, 0)
if err != nil {
return "", err
}
var res map[string]interface{}
if err := parseBody(resp, &res); err != nil {
return "", err
}
if val,... | func (resource Resource) Delete(w http.ResponseWriter, r *http.Request) {
var id int64
_, err := fmt.Sscanf(r.URL.Query().Get(":"+resource.Kind), "%d", &id)
if err != nil {
resource.GetErrorFunction()(w, err, http.StatusBadRequest)
return
}
entity := reflect.New(resource.GetPrototype()).Interface().(Entity)
... | func (s *NSClient) Delete(ctx context.Context, key string) (obj meta.Object, err error) {
if strings.HasSuffix(key, "/") {
return nil, fmt.Errorf("error format key, cannot end with /")
}
fullPath := s.prefixPath
if len(key) == 0 {
blog.Warnf("zk namespace client ready to clean all data under %s", s.prefixPath)
... | func SirenDelete(id int64) error {
if id == 0 {
return nil
}
_, err := pool.Exec(context.Background(), `
DELETE FROM
sirens
WHERE
id = $1
`, id)
if err != nil {
errmsg("DeleteSiren Exec", err)
}
return err
} | func (store *StoreType) DeleteByTitle(title string, name string) error {
fmt.Printf("DEL VALUES: %s/%s\n", title, name)
_, err := store.DAO.Query(`DELETE FROM Todos WHERE title = ? AND acct_name = ?`, title, name)
return err
} | func DeleteRecord(who string) {
var email, hold string
fmt.Print("Login ID: ")
fmt.Scan(&email)
fmt.Println()
if email == "user" && who == "employee" {
print.Invalid()
} else {
sql1 := ``
sql2 := ``
if who == "customer" {
sql1 = `select email from customer where email = $1`
sql2 = `delete from cust... | func (c *Client) DeleteRecord(domainID, recordID int) error {
uri := fmt.Sprintf("/%d/records/%d", domainID, recordID)
req, err := c.newRequest(http.MethodDelete, uri, nil)
if err != nil {
return err
}
_, err = c.do(req, nil)
return err
} | func (s *Store) DeleteResource(ctx context.Context, resourcePrefix, name string) error {
key := store.KeyFromArgs(ctx, resourcePrefix, name)
return Delete(ctx, s.client, key)
} | func (this MongoDb) Delete(record interface{}) bool {
if record == nil {
return false
}
var err error
if reflect.TypeOf(record).String() == "string" {
record = entity.Json(record.(string)).ToObject()
err = this.Conn.Remove(bson.M{"_id": bson.ObjectIdHex(record.(entity.Map)["_id"].(string)... | func (s *store) Delete(k string) error {
if k == "" {
return errors.New("key is mandatory")
}
req := s.db.Call("transaction", s.name, "readwrite").Call("objectStore", s.name).Call("delete", k)
_, err := getResult(req)
if err != nil {
return fmt.Errorf("failed to delete data with key: %s - error: %w", k, err)... | func (ch *CredHub) Delete(name string) error {
query := url.Values{}
query.Set("name", name)
resp, err := ch.Request(http.MethodDelete, "/api/v1/data", query, nil, true)
if err == nil {
defer resp.Body.Close()
}
return err
} | func (m *MongodbStore) Delete(colletionname string, condmap map[interface{}]interface{}) error {
sess, err := mongo.Open(m.Config)
if err != nil {
log.Fatalf("db.Open(): %q\n", err)
return errors.New(fmt.Sprintf("db.Open(): %q\n", err))
}
defer sess.Close() // Remember to close the database session.
// Pointi... | func Delete(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
key := vars["deleteId"]
log.Println("executing Delere", key)
if !authenticate(r) {
w.WriteHeader(http.StatusUnauthorized)
return
}
if r.Method == "POST" {
db := ardb.DbConn()
col := ardb.GetCollection(db)
rs, err := utilreaddoc... | func (db *Database) Delete(sid string, key string) (deleted bool) {
ctx := context.Background()
query := `{
q(func: eq(sid, "` + sid + `")) {
v as uid
}
}`
deletion := `uid(v) "` + key + `" * . `
req := &api.Request{
Query: query,
Mutations: []*api.Mutation{
{
DelNquads: []byte(deletion),
... | func (nameservers *NameServers) Delete(ctx context.Context, domain, id string) (err error) {
response, err := httpDo(ctx, nameservers.Options, "DELETE", apiURL("/domain/%s/nameServer/%s", domain, id), nil)
if err != nil {
return
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
return un... | func (c *Client) Delete(name string) error {
if err := c.ensureAuthenticated(); err != nil {
return err
}
cmd := &commands.Delete{
Mailbox: name,
}
status, err := c.execute(cmd, nil)
if err != nil {
return err
}
return status.Err()
} | func (s *ChallSrv) DeleteDNSAAAARecord(host string) {
s.challMu.Lock()
defer s.challMu.Unlock()
host = dns.Fqdn(host)
delete(s.dnsMocks.aaaaRecords, host)
} | func (s *MongoDB) Delete(ident string) error {
log.Println("Deleting ident", ident)
return nil
} | func (t *NFSTracer) Delete(ctx context.Context, zone string, id types.ID) error {
log.Println("[TRACE] NFSAPI.Delete start")
targetArguments := struct {
Argzone string
Argid types.ID `json:"id"`
}{
Argzone: zone,
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Printf("[TRACE... | func (self *server) Delete(ctx context.Context, rqst *persistencepb.DeleteRqst) (*persistencepb.DeleteRsp, error) {
store := self.stores[rqst.GetId()]
if store == nil {
err := errors.New("No store connection exist for id " + rqst.GetId())
return nil, status.Errorf(
codes.Internal,
Utility.JsonErrorStr(Utili... | func (s *URLStore) Delete(record *URL) error {
return s.Store.Delete(Schema.URL.BaseSchema, record)
} | func (s *REST) Delete(ctx kapi.Context, name string) (runtime.Object, error) {
return &unversioned.Status{Status: unversioned.StatusSuccess}, s.client.Delete(name)
} | func (s *boltStore) Delete(name string, key []byte) error {
s.log.Debugf("delete: key: %s", key)
if err := storage.ValidKey(name, key); err != nil {
return s.logError("delete", err)
}
del := func(tx *bolt.Tx) error {
s.log.Debugf("delete: tx key: %s.%s", name, string(key))
b := tx.Bucket([]byte(name))
if b ... | func (s *Store) Delete(name string) error {
delete(s.accounts, name)
return nil
} | func (c *FakeRoute53Records) Delete(name string, options *v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(route53recordsResource, c.ns, name), &v1alpha1.Route53Record{})
return err
} | func DeleteRecord(data InputData) error {
if err := valdidateInput(data, "check"); err != nil {
return err
}
date, err := time.Parse("2006-01-02", data.Date)
if err != nil {
return errors.New("Incorrect date format")
}
if err := valdidateInput(data, "check-order"); err != nil {
return err
}
_, err = conn.... | [
"0.6567878",
"0.6565942",
"0.633063",
"0.62859195",
"0.62643176",
"0.62055933",
"0.6163259",
"0.61351025",
"0.6128934",
"0.61089885",
"0.60666347",
"0.6054383",
"0.60459256",
"0.6019277",
"0.5991292",
"0.597775",
"0.5954871",
"0.59509706",
"0.5929179",
"0.5916825",
"0.5880952... |
Delete NS record by its id | func deleteNsById(nsID string, payload *strings.Reader, c Config) {
url := BASE_URL + c.Constellix.Domain + "/records/ns/" + nsID
send(url, DELETE, payload, c)
if filepath.Base(url) == "0" {
fmt.Println("Error: Wrong id -> ", url)
} else {
fmt.Println("Domain record deleted successfully ", url)
}
} | func deleteRecord(c echo.Context) error {
id, _ := strconv.Atoi(c.Param("id"))
delete(records, id)
return c.NoContent(http.StatusNoContent)
} | func (client DataLabelingClient) deleteRecord(ctx context.Context, request common.OCIRequest, binaryReqBody *common.OCIReadSeekCloser, extraHeaders map[string]string) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodDelete, "/records/{recordId}", binaryReqBody, extraHeaders)
if err !=... | func delete(id int) {
db := connect()
db.QueryRow("DELETE FROM crudop WHERE id=?", id)
} | func (c collection) deleteID(ctx context.Context, hex string, ptr are_hub.Archetype) error {
id, e := primitive.ObjectIDFromHex(hex)
if e != nil {
return e
}
return c.get().FindOneAndDelete(ctx, bson.M{"_id": id}).Decode(ptr)
} | func (s *stripIDPrefix) Delete(apiOp *types.APIRequest, schema *types.APISchema, id string) (types.APIObject, error) {
return s.Store.Delete(apiOp, schema, stripPrefix(id))
} | func deleteRecord(t *testing.T, dbo *sql.DB) {
// delete the record with id 1
exec(t, dbo, "DELETE FROM "+tableName+" WHERE id = ?;", testingID)
data := selectWhere(t, dbo, "id = ?", testingID)
assert.Equal(t, 0, len(data))
} | func DeleteRecord(id int) {
db := OpenDb()
defer db.Close()
db.Exec(deleteRecordPerID, id)
} | func (dao *DAO) Delete(rs app.RequestScope, id bson.ObjectId) error {
if _, err := dao.GetOne(rs, id); err != nil {
return err
}
c := rs.Tx().DB(app.Config.DBNAME).C(collection)
return c.Remove(bson.M{"_id": id})
} | func (c *Client) DeleteRecord(ctx context.Context, domain string, id int) error {
endpoint, err := c.BaseURL.Parse(path.Join(c.BaseURL.Path, "dns", "delete", domain, strconv.Itoa(id)))
if err != nil {
return fmt.Errorf("failed to parse endpoint: %w", err)
}
respBody, err := c.do(ctx, endpoint, nil)
if err != ni... | func (m *Mongo) Delete(entity, id string) error {
if !bson.IsObjectIdHex(id) {
return errors.New("Invalid Id Hex")
}
s := m.Session.Copy()
defer s.Close()
c := s.DB("").C(entity)
return c.Remove(bson.M{"_id": bson.ObjectIdHex(id)})
} | func (c *Com) Delete(id interface{}) error {
return c.Crud().Params(gt.Model(c.Model)).Delete(id).Error()
} | func Delete(id bson.ObjectId) error {
//open connection
db, err := storm.Open(dbPath)
if err != nil {
return err
}
//close the db connection to avoid dataleaks
defer db.Close()
u := new(User) //new keyword return the pointer to the structure
err = db.One("ID", id, u) //(Field cointaining unique id... | func (s *Store) DeleteRecord(id string) error {
return s.Records.Delete(
[]byte(id),
)
} | func (d *dataEditorObject) deleteById(appcontext interface{}, arguments interface{}) (interface{}, error) {
context := appcontext.(Context)
var err error
id := context.GetParameters()["id"] //get the id of the object to delete
fmt.Println("DataEditor::deleteById", context.GetParameters(), "started")
collection :=... | func (s *NameserverService) DeleteRecord(recID int) error {
req := s.client.NewRequest(methodNameserverDeleteRecord, map[string]interface{}{
"id": recID,
})
_, err := s.client.Do(*req)
if err != nil {
return err
}
return nil
} | func (resolver *RootResolver) Deletebyid(ctx context.Context, args struct{
ID int32
Token string
}) (audioModel.DeleteResolver){
db := db.GetConnection()
var audio audioModel.Audio1
var info audioModel.DeleteHandler
user1, err := auth.ValidateToken1(args.Token)
if err != nil {
info.Message = "Unathorized... | func Delete(writer http.ResponseWriter, request *http.Request) {
vars := mux.Vars(request)
id, _ := vars["id"]
session, collection := database.GetCollection(models.TableKanji)
defer session.Close()
err := collection.RemoveId(bson.ObjectIdHex(id))
if err != nil {
response.NotFound(writer)
return
}
respo... | func deleteStatus(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
idParam, _ := strconv.ParseUint(params["id"], 10, 16)
status := &DndStatus{ID: uint(idParam)}
_, err := core_module.Db.Model(status).WherePK().Delete()
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
json.... | func (u *ORM) Delete(db *gorm.DB, id string) (err error) {
return zaplog.ZLog(db.Where("uuid = ?", id).Delete(&model.File{}).Error)
} | func (s *ApikeysServiceOp) DeleteById(id string) (error) {
endpoint := fmt.Sprintf("apikeys/%s", id)
return s.DeleteByLink(endpoint)
} | func (s *Service) Delete(id string) error {
logger := s.logger.With(zap.String("imageId", id))
//get record from id
rec, err := s.reader.Get(id)
switch err {
case nil:
case images.ErrRecordNotFound:
logger.Error("record not found", zap.Error(err))
return err
default:
const msg = "unable to retrieve image... | func resourceRage4RecordDelete(d *schema.ResourceData, meta interface{}) error {
// get which domain we're working on
recordId, err := strconv.Atoi(d.Id())
if (err != nil) {
return fmt.Errorf("Failed to get Rage4 record id: %s", err)
}
domain := d.Get("domain")
log.Printf("[INFO] Deleting Rage4 Record... | func deleteCharacter(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
idParam, _ := strconv.ParseUint(params["id"], 10, 16)
character := &DndCharacter{ID: uint(idParam)}
_, err := core_module.Db.Model(character).WherePK().Delete()
if err != nil {
w.WriteHeader(http.StatusInternalServerErr... | func (s *Service) Delete(subject, reply, id string) error {
if len(id) != 36 {
return s.jsonConn.Publish(reply, &model.NATSMsg{Success: false, Message: model.ErrInvalidID.Error()})
}
delS := "UPDATE Freelancer SET deleted_at=$1 WHERE id=$2"
if _, err := s.db.Exec(delS, time.Now(), id); err != nil {
return s.jso... | func deleteRecord(c *godo.Client, zoneName string, recordID int) error {
resp, err := c.Domains.DeleteRecord(context.TODO(), zoneName, recordID)
if err != nil {
return fmt.Errorf("error applying changeset: %v", err)
}
if err = handleResponse(resp); err != nil {
return err
}
return nil
} | func Notebooks_delete_by_id() {
// DELETE /notebooks/{id}.json
} | func (act *Record) Delete() {
for reply, index, records := struct {
Status Status `json:"status"`
}{}, 0, act.ListRecords(); index < len(records); index++ {
body := act.NewRequestBody(map[string]string{"record_id": records[index]}, "ttl", "sub_domain").GetReader()
if exitIfErr(request(http.MethodPost, actions.D... | func DeleteRecord(id uuid.UUID) error {
return Delete([]byte(RecordsBucket), []byte(id.String()))
} | func (r repository) Delete(ctx context.Context, id string) error {
short, err := r.Get(ctx, id)
if err != nil {
return err
}
return r.db.With(ctx).Model(&short).Delete()
} | func (r rdbGateway) Delete(id string) error {
_, err := rdb.Table(r.TableName).Get(id).Delete().RunWrite(r.session)
return err
} | func (t *DNSTracer) Delete(ctx context.Context, id types.ID) error {
log.Println("[TRACE] DNSAPI.Delete start")
targetArguments := struct {
Argid types.ID `json:"id"`
}{
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Printf("[TRACE] \targs: %s\n", string(d))
}
defer func() {
l... | func (account *Account) deleteById(id string) {
fmt.Println("delete account by id")
} | func (resource Resource) Delete(w http.ResponseWriter, r *http.Request) {
var id int64
_, err := fmt.Sscanf(r.URL.Query().Get(":"+resource.Kind), "%d", &id)
if err != nil {
resource.GetErrorFunction()(w, err, http.StatusBadRequest)
return
}
entity := reflect.New(resource.GetPrototype()).Interface().(Entity)
... | func deleteArmor(w http.ResponseWriter, r *http.Request) {
core_module.InitResponse(&w)
if (r.Method == "OPTIONS") {return}
params := mux.Vars(r)
idParam, _ := strconv.ParseUint(params["id"], 10, 16)
armor := &DndArmor{ID: uint(idParam)}
_, err := core_module.Db.Model(armor).WherePK().Delete()
if err !=... | func (this MongoDb) Delete(record interface{}) bool {
if record == nil {
return false
}
var err error
if reflect.TypeOf(record).String() == "string" {
record = entity.Json(record.(string)).ToObject()
err = this.Conn.Remove(bson.M{"_id": bson.ObjectIdHex(record.(entity.Map)["_id"].(string)... | func (m *ShareModel) DeleteById(id int64) (int64, error) {
return m.Condition(query.Builder().Where("id", "=", id)).Delete()
} | func (mk *Matkul) Delete(db *sql.DB) error {
if mk.ID == "" {
return fmt.Errorf("id tidak bolehh kosong")
}
query := "DELETE FROM matkul where id = $1"
_, err := db.Exec(query, &mk.ID)
return err
} | func (r *Repository) Delete(id string) (err error) {
db, err := r.DB.GetDB()
if err != nil {
return
}
tx, err := db.Begin()
if err != nil {
return
}
// prepare transaction
stmt, err := tx.Prepare("DELETE FROM tracks WHERE uid=?")
if err != nil {
return err
}
res, err := stmt.Exec(id)
if err != nil {... | func (c RepSysCtrl) Delete(id uint32) revel.Result {
u := models.User{}
if err := Dbm.Debug().Where("user_id = ?", id).Delete(&u).Error; err != nil {
return c.RenderJson(err)
}
return c.RenderText("Deleted user %v", id)
} | func deleteByID(c echo.Context) error {
db := c.Get("DB").(*storage.Docktor)
group := c.Get("group").(types.Group)
err := db.Groups().Delete(group.ID.Hex())
if err != nil {
log.WithFields(log.Fields{
"groupID": c.Param(types.GROUP_ID_PARAM),
"error": err,
}).Error("Error when deleting group")
return ... | func (c *Client) DeleteRecord(sheet string, id int) error {
fullURL := fmt.Sprintf("%s/%s/%v", c.getURL(), sheet, id)
req, err := http.NewRequest("DELETE", fullURL, nil)
if err != nil {
return err
}
_, _, err = c.doReq(req)
if err != nil {
return err
}
//log.Println(string(slurp))
return nil
} | func DeleteRecord(c *gin.Context) {
var record models.Record
if err := models.DB.Where("id = ?", c.Param("id")).First(&record).Error; err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Record not found!"})
return
}
var files []models.File
models.DB.Where("record_id = ?", record.ID).Find(&files)
if mo... | func Delete(table string, id interface{}, session *r.Session) {
err := r.Table(table).Get(id).Delete().Exec(session)
if err != nil {
raven.CaptureError(err, nil)
log.Fatal(err.Error())
}
} | func RecordDelete(d *schema.ResourceData, meta interface{}) error {
client := meta.(*ns1.Client)
_, err := client.Records.Delete(d.Get("zone").(string), d.Get("domain").(string), d.Get("type").(string))
d.SetId("")
return err
} | func (p Database) Delete(id, rev string) error {
headers := map[string][]string{
"If-Match": []string{rev},
}
u := fmt.Sprintf("%s/%s", p.DBURL(), id)
ir := Response{}
if err := interact("DELETE", u, headers, nil, &ir); err != nil {
return err
}
if !ir.Ok {
return fmt.Errorf("%s: %s", ir.Error, ir.Reason)
... | func (dbobj PGSQLDB) DeleteRecord(t Tbl, keyName string, keyValue string) (int64, error) {
tbl := GetTable(t)
return dbobj.DeleteRecordInTable(tbl, keyName, keyValue)
} | func (r *Repository) Delete(ctx context.Context, id primitive.ObjectID) error {
filter := bson.M{"_id": id}
_, err := r.coll.DeleteOne(ctx, filter)
if err != nil {
r.log.Error(err)
return response.ErrorInternalServerError
}
return nil
} | func (tp *TarantoolRepo) DeleteByID(id int) error {
_, err := tp.conn.Delete(tp.spaceName, 0, []interface{}{id})
if err != nil {
log.Println(err)
}
return err
} | func (pr *RouteDomainResource) Delete(id string) error {
if err := pr.c.ModQuery("DELETE", BasePath+RouteDomainEndpoint+"/"+id, nil); err != nil {
return err
}
return nil
} | func del(db Db, res http.ResponseWriter, vars map[string]string, enc *json.Encoder, dec *json.Decoder) {
// delete resource
dbRes := db.Delete(vars["collection"], vars["id"])
// write response
res.WriteHeader(dbRes.StatusCode())
err := enc.Encode(apiResponse{dbRes.Error(), "", nil})
if err != nil {
log.Println... | func (h *HTTP) delete(c echo.Context) error {
id, err := strconv.Atoi(c.Param("id"))
if err != nil {
return model.ErrBadRequest
}
uid := uint(id)
if err := h.svc.Delete(c, uid); err != nil {
return err
}
return c.NoContent(http.StatusOK)
} | func (r *Record) Delete(client *godo.Client) error {
_, err := client.Domains.DeleteRecord(context.TODO(), r.zoneName.String(""), r.ID)
return err
} | func (*server) Delete(ctx context.Context, req *model.DeleteReq) (*model.DeleteResp, error) {
ID := req.GetId()
blogID, err := primitive.ObjectIDFromHex(ID)
log.Printf("Req => %v\n", req)
if err != nil {
errMsg := status.Errorf(codes.InvalidArgument, "Failed read ID")
return nil, errMsg
}
data := &dataItem... | func Delete(id string) error {
params := &dynamodb.DeleteItemInput{
TableName: aws.String(buildTableName),
Key: map[string]*dynamodb.AttributeValue{
"Id": {
S: aws.String(id),
},
},
}
resp, err := db.DeleteItem(params)
if err != nil {
return err
}
log.Debugln(resp)
return nil
} | func (r *Repository) Delete(id int) error {
session := r.driver.NewSession(neo4j.SessionConfig{})
defer session.Close()
_, err := session.WriteTransaction(func(transaction neo4j.Transaction) (interface{}, error) {
_, err := transaction.Run(
"MATCH (d) where ID(d)=$id DETACH DELETE d",
map[string]interface{... | func (db *Database) Del(id, rev string) (string, error) {
resp, err := db.conn.request("DELETE", queryURL(
db.Name, id) + fmt.Sprintf("?rev=%s", rev), nil, nil, db.auth, 0)
if err != nil {
return "", err
}
var res map[string]interface{}
if err := parseBody(resp, &res); err != nil {
return "", err
}
if val,... | func (t *EnhancedDBTracer) Delete(ctx context.Context, id types.ID) error {
log.Println("[TRACE] EnhancedDBAPI.Delete start")
targetArguments := struct {
Argid types.ID `json:"id"`
}{
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Printf("[TRACE] \targs: %s\n", string(d))
}
defe... | func (impl *DB) Delete(id string) (ModelInterface, *ErrorResponse) {
var (
name = impl.TemplateImpl.ResourceName()
record = impl.TemplateImpl.NewEntity()
previous = impl.TemplateImpl.NewEntity()
c = impl.TemplateImpl.GetConnection()
)
tx := c.Begin()
if err := tx.Error; err != nil {
log.With... | func (t *NFSTracer) Delete(ctx context.Context, zone string, id types.ID) error {
log.Println("[TRACE] NFSAPI.Delete start")
targetArguments := struct {
Argzone string
Argid types.ID `json:"id"`
}{
Argzone: zone,
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Printf("[TRACE... | func (s *Service) Delete(subject, reply, id string) error {
if len(id) != 36 {
return s.jsonConn.Publish(reply, &model.NATSMsg{Success: false, Message: model.ErrInvalidID.Error()})
}
delS := "UPDATE Client SET deleted_at=$1 WHERE id=$2"
if _, err := s.db.Exec(delS, time.Now(), id); err != nil {
return s.jsonCon... | func (api *API) ReportedRecordDelete(c *gin.Context) {
ID := c.Param("id")
IDn, err := strconv.ParseUint(ID, 10, 32)
if err != nil {
logger.Log.Error("ReportedRecordsDelete, param 'id' is missing:", err)
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
reportedRecords := api.reportedRecor... | func (store *PostgressStore) Delete(id int64) error {
res, err := store.PostgressDB.Exec(sqlDeleteStatement, id)
if err != nil {
return err
}
fmt.Printf("Res found: %v", res)
fmt.Printf("Res deleted: %v", id)
return nil
} | func (m *MongoAccessor) Delete(id task.ID) error {
return m.collection.RemoveId(idToObjectId(id))
} | func DelByFsId(db *sql.DB, id string) (sql.Result, error) {
return db.Exec("delete from venue where fs_id=$1", id)
} | func (vega *VegaDNSClient) DeleteRecord(recordID int) error {
resp, err := vega.Send("DELETE", fmt.Sprintf("records/%d", recordID), nil)
if err != nil {
return fmt.Errorf("Send DELETE error in DeleteTXT: %s", err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return fmt.Erro... | func Delete(id uint) error {
// gorm will delete all of the records if the id equals to zero.
if id == 0 {
return ErrorInvaildID
}
// Gorm delete needs the primary key with the reference of the object to understand which table we are deleting from.
user := User{
Model: gorm.Model{
... | func (api *API) ReportedRecordDelete(w http.ResponseWriter, req *http.Request) {
vars := mux.Vars(req)
ID := vars["id"]
IDn, err := strconv.ParseUint(ID, 10, 32)
if err != nil {
fmt.Println("ReportedRecordsDelete, param 'id' is missing:", err)
return
}
reportedRecords := api.reportedRecords.ReportedRecordsDel... | func (r *StateMirroringResource) Delete(id string) error {
if err := r.c.ModQuery("DELETE", BasePath+StateMirroringEndpoint+"/"+id, nil); err != nil {
return err
}
return nil
} | func deleteDataRow(id bson.ObjectId) bool {
q := bson.M{"_id": id}
err := db.C("data").Remove(q)
if err != nil {
log.Println(err)
return false
}
return true
} | func DeleteArecord() {
dbService := db.NewDbService(os.Getenv("MICRO_API_TOKEN"))
rsp, err := dbService.Delete(&db.DeleteRequest{
Id: "1",
Table: "users",
})
fmt.Println(rsp, err)
} | func (s *RecordsService) Delete(domain string, recordID string) (*Response, error) {
payload := s.client.CommonParams.toPayLoad()
payload.Add("domain_id", domain)
payload.Add("record_id", recordID)
returnedRecord := recordWrapper{}
res, err := s.client.post(methodRecordRemove, payload, &returnedRecord)
if err !... | func (api *API) DeleteDNSRecord(zone, id string) error {
z, err := api.ListZones(zone)
if err != nil {
return err
}
// TODO(jamesog): This is brittle, fix it
zid := z[0].ID
uri := "/zones/" + zid + "/dns_records/" + id
res, err := api.makeRequest("DELETE", uri, nil)
if err != nil {
fmt.Println("Error with m... | func (r *Repo) Delete(ctx context.Context, named repository.Named, id string) error {
var oid, err = primitive.ObjectIDFromHex(id)
var res *mongo.DeleteResult
if err == nil {
res, err = r.db.Collection(named.Name()).DeleteOne(ctx, bson.M{"_id": oid})
}
if err == nil && res.DeletedCount == 0 {
err = repositor... | func DeleteRepasById(tx DB, id int64) (Repas, error) {
row := tx.QueryRow("DELETE FROM repass WHERE id = $1 RETURNING *;", id)
return ScanRepas(row)
} | func (r *MongoRepository) Delete(id string) error {
oID, err := primitive.ObjectIDFromHex(id)
if err != nil {
return err
}
_, err = r.db.Collection.DeleteOne(
context.Background(),
bson.M{"_id": oID},
)
if err != nil {
return err
}
return nil
} | func (s *TxtRecordService) Delete(ctx context.Context, domainID, recordID int64) (*SuccessMessage, error) {
endpoint, err := s.client.createEndpoint(defaultVersion, "domains", strconv.FormatInt(domainID, 10), "records", "txt", strconv.FormatInt(recordID, 10))
if err != nil {
return nil, fmt.Errorf("failed to create... | func eliminarPersona(id int) {
db, err := gorm.Open("postgres", "host=localhost port=5432 user=postgres dbname=golang password=1234 sslmode=disable")
defer db.Close()
if err != nil {
log.Fatal(err.Error())
}
db.Table("personas").Where("id = ?", id).Delete(&Persona{})
fmt.Println("Persona eliminada")
} | func (s FarmAPI) Delete(ctx context.Context, db *mongo.Database, id int64) error {
var filter directory.FarmFilter
filter = filter.WithID(schema.ID(id))
return filter.Delete(ctx, db)
} | func (s *SmartContract) DeleteRecord(ctx contractapi.TransactionContextInterface, id string) error {
exists, err := s.RecordExists(ctx, id)
if err != nil {
return err
}
if !exists {
return fmt.Errorf("the record %s does not exist", id)
}
return ctx.GetStub().DelState(id)
} | func (r *RedisSaver) Delete(id string) error {
conn := r.pool.Get()
defer conn.Close()
// job info
key := fmt.Sprintf(JobInfoPrefix, id)
if _, err := conn.Do("DEL", key); err != nil {
logrus.Error(err)
return err
}
return nil
} | func ModelDelete(tablename string, ID uint64) error {
query := `delete from ` + tablename + ` where id=` + strconv.FormatUint(ID, 10) + `;`
if verboseMode {
fmt.Printf("Query : %s\n", query)
}
_, err := dbx.Exec(query)
if err != nil {
if verboseMode {
fmt.Printf("Error : %s\n", err.Error())
}
return err... | func (t *DatabaseTracer) Delete(ctx context.Context, zone string, id types.ID) error {
log.Println("[TRACE] DatabaseAPI.Delete start")
targetArguments := struct {
Argzone string
Argid types.ID `json:"id"`
}{
Argzone: zone,
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Prin... | func (s Service) DeleteByID(id string) error {
db := db.GetDB()
var i Item
if err := db.Where("id = ?", id).Delete(&i).Error; err != nil {
return err
}
return nil
} | func deleteByID(c *gin.Context) {
// return specific user by Teacher ID
db, errdb := model.GetDB()
if errdb != nil {
fmt.Println(errdb)
}
tid := c.Param("id")
var teacher model.Teacher
// Get first matched record
db.Where(&model.Teacher{TID: tid}).First(&teacher)
db.Delete(&teacher)
c.JSON(http.StatusOK, gi... | func (service *MatchService) Delete(id uint) error {
match, err := service.Get(id)
if err != nil {
return err
}
return service.Database.Delete(match).Error
} | func deleteEntry(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id, err := strconv.Atoi(vars["id"])
if err != nil {
fmt.Fprintf(w, "Index is not an integer: %d", id)
}
newEntries, err := model.DeleteEntry(id)
if err != nil {
fmt.Fprintf(w, "Error deleting entry: %v", err)
retu... | func (c *Client) DeleteRecord(domainID, recordID int) error {
uri := fmt.Sprintf("/%d/records/%d", domainID, recordID)
req, err := c.newRequest(http.MethodDelete, uri, nil)
if err != nil {
return err
}
_, err = c.do(req, nil)
return err
} | func (e *Store) Delete(id string, pid int) {
e.Lock()
delete(e.byID, id)
e.Unlock()
} | func deleteDataById(id int) error {
db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:3306)/%s",
os.Getenv("DB_USER"),
os.Getenv("DB_PASSWORD"),
os.Getenv("DB_ADDRESS"),
os.Getenv("DB_DATABASE"),
))
if err != nil {
return err
}
q := "DELETE FROM `product` WHERE `id` = ?"
drop, err :=... | func (c *PhysicaltherapyrecordClient) DeleteOneID(id int) *PhysicaltherapyrecordDeleteOne {
builder := c.Delete().Where(physicaltherapyrecord.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &PhysicaltherapyrecordDeleteOne{builder}
} | func deleteRecord(stub shim.ChaincodeStubInterface, args []string) peer.Response {
if len(args) != 2 {
return shim.Error(errorIncorrectParamNum + " Expecting 2")
}
fmt.Println("args=", args)
objectName := args[0]
if objectName == "" {
return shim.Error(errorMissParam + " Expect object name")
}
keywords := ... | func (t *NoteTracer) Delete(ctx context.Context, id types.ID) error {
log.Println("[TRACE] NoteAPI.Delete start")
targetArguments := struct {
Argid types.ID `json:"id"`
}{
Argid: id,
}
if d, err := json.Marshal(targetArguments); err == nil {
log.Printf("[TRACE] \targs: %s\n", string(d))
}
defer func() {
... | func (r *NoteRepository) Delete(id string) error {
err := r.C.Remove(bson.M{"_id": bson.ObjectIdHex(id)})
return err
} | func (c *CRDBManager) Delete(id string) error {
return nil
} | func DeleteAsn(w http.ResponseWriter, req *http.Request) {
db, err := myconfig.GetMysqlConnect()
id := req.FormValue("id")
db.Exec("DELETE FROM sim_asn WHERE id = " + id)
helper.CheckErr(err)
http.Redirect(w, req, "/", http.StatusSeeOther)
} | func (r *PFManResource) Delete(id string) error {
if err := r.c.ModQuery("DELETE", BasePath+PFManEndpoint+"/"+id, nil); err != nil {
return err
}
return nil
} | func deleteBird(id string)error {
return nosql.GetHandle().Delete(id)
} | func (s LibraryService) Delete(id string) error {
return db.DeleteRethinkDBDocument(id, s.Table, s.Session)
} | func Delete(w http.ResponseWriter, r *http.Request) {
handler := newHandler()
vars := mux.Vars(r)
id, err := strconv.Atoi(vars["id"])
if err != nil {
utils.RespondWithError(w, http.StatusBadRequest, "Invalid ID")
return
}
defer r.Body.Close()
if err := handler.delete(id); err != nil {
utils.RespondWithErr... | func (r *MongoRepository) Delete(id bson.ObjectId) error{
session := r.mongoSession.Clone()
defer session.Close()
coll := session.DB(r.db).C(collectionName)
err := coll.Remove(bson.M{"_id": bson.ObjectId(id)})
return err
} | [
"0.73538303",
"0.6997496",
"0.69181335",
"0.6876886",
"0.68364143",
"0.6797977",
"0.6763279",
"0.6755305",
"0.6695033",
"0.66903496",
"0.668096",
"0.66743296",
"0.66734433",
"0.6640447",
"0.6619129",
"0.66159034",
"0.6606549",
"0.66063285",
"0.6588125",
"0.6588097",
"0.657458... |
World returns the word world. | func (g *GreeterEnglish) World() string {
return "World"
} | func (l *Loader) World() *World {
l.mu.RLock()
defer l.mu.RUnlock()
return l.w
} | func (n *Node) World() api.IWorld {
return n.world
} | func (wp WayPoint) World() context.WorldHandler {
return wp.world
} | func World(ctx context.Context) (*WorldResponse, error) {
msg := fmt.Sprintf("Hello, World!")
return &WorldResponse{Message: msg}, nil
} | func Word() string {
return lookup(lang, "words", true)
} | func (m *DuplicateNumberMessageMutation) World() (r string, exists bool) {
v := m.world
if v == nil {
return
}
return *v, true
} | func (e *Entity) World() *world.World {
return e.world
} | func GetWorld() *world.World {
return worldController
} | func Word() string {
return getRandValue([]string{"lorem", "word"})
} | func (server *Server) World(name string) *world.World {
//Check if the world is loaded
server.worlds.RLock()
w := server.worlds.m[name]
server.worlds.RUnlock()
if w == nil { //World isn't loaded
server.worlds.Lock()
if w = server.worlds.m[name]; w != nil { //Double check now we have the lock
return w
}
... | func (obj *Connection) World() World {
return World(obj.msgBuf)
} | func Word() string {
args := Args()
if len(args) > 0 {
return args[len(args)-1]
}
return ""
} | func NewWorld() World {
return World{C.xcl_world_single()}
} | func NewWorld(b Board) *World {
return &World{last: NewBoard(), current: &b}
} | func (g *Generator) Word() string {
return g.OneStringOf(words...)
} | func (l *Lorem) Word() string {
return l.pick(loremPrefix + "/words")
} | func world(w http.ResponseWriter, r *http.Request) {
page := ui.NewRoot("World") // "World" option will be active on the navbar
page.H1("World!")
page.GenTiles(embgui.Tile{Title: "7", Subtitle: "new users"},
embgui.Tile{Title: "71", Subtitle: "new sales"},
embgui.Tile{Title: "90%", Subtitle: "CPU usage"},
embg... | func (s *Server) GetWorld(args stubs.Default, reply *stubs.World) error {
s.distributor.mutex.Lock()
reply.Turn = s.distributor.currentTurn
reply.World = s.distributor.prevWorld
reply.Height = s.distributor.imageHeight
reply.Width = s.distributor.imageWidth
s.distributor.mutex.Unlock()
return nil
} | func NewWorld(name, displayName, srv, username, password string, logByDefault bool) *World {
return &World{
Name: name,
DisplayName: displayName,
Server: srv,
Username: username,
Password: password,
Log: logByDefault,
}
} | func NewWorld() *World {
return &World{make(map[string]*GameMap), nil}
} | func (svc *wordSvc) Word(ctx contextHeaders) (string, error) {
rsp, err := svc.request(ctx, "GET", &url.URL{}, nil)
if err != nil {
return "", err
}
switch rsp.StatusCode {
case http.StatusOK:
var word wordRsp
if err := json.NewDecoder(rsp.Body).Decode(&word); err != nil {
return "", err
}
io.Copy(io... | func (o *Object) WorldSpace(c mgl32.Vec3) mgl32.Vec3 {
return o.GetModel().Mul4x1(c.Vec4(1.0)).Vec3()
} | func ByeWorld() int {
return 0
} | func (dnmuo *DuplicateNumberMessageUpdateOne) SetWorld(s string) *DuplicateNumberMessageUpdateOne {
dnmuo.mutation.SetWorld(s)
return dnmuo
} | func (l *lipsum) Word() string {
idx := l.updateIdx()
word := l.dictionary[idx]
return word
} | func (v Vocabulary) Word(w string) (Word, error) {
if w == "" {
return Word{}, Error("word must be non-empty string")
}
if v.c.BigHugeLabsApiKey == "" {
return Word{}, Error("BigHugeLabsApiKey required.")
}
if v.c.WordnikApiKey == "" {
return Word{}, Error("WordnikApiKey required.")
}
meanin... | func (stem Stem) Word() Word {
w := Word(make([]rune, len(stem)))
copy(w, stem)
if !Vowel[w[len(w)-1]] {
/* value of prev is irrelevant; next == 0 implies a voiceless */
w[len(w)-1] = resolve_cons(0, w[len(w)-1], 0)
}
return w
} | func (w *WordResp) Word() string {
return w.word
} | func NewWorld(width, height int) *World {
world := World{}
world.area = makeArea(width, height)
world.width = width
world.height = height
return &world
} | func NewWorld() World {
nw := World{}
audioContext, _ := audio.NewContext(44100)
nw.AudioContext = audioContext
return nw
} | func (c *TRandomText) Word() string {
return RandomString.Pick(allWords)
} | func NewWorld(wc Config, objects []Object) (*World, error) {
log.Println("Initializing world...")
log.Println(wc)
return &World{
name: wc.Name,
config: wc,
objects: objects,
}, nil
} | func (t *Translator) Word(input string) string {
t.pigify([]byte(input))
return string(t.buff)
} | func NewWorld(h, w int) *World {
if h == 0 {
h = 1
}
if w == 0 {
w = 1
}
wo := World{
boardOne: emptyBoard(h+2*padding, w+2*padding),
boardTwo: emptyBoard(h+2*padding, w+2*padding),
}
wo.board = &wo.boardOne
return &wo
} | func (g Generator) Word() string {
return g.source[g.r.Intn(g.len)]
} | func NewWorld() *World {
w := &World{
CollisionIterations: 100,
PenetrationAllowance: 0.05,
PenetrationCorrection: 0.4,
CurrentTime: 0,
DeltaTime: time.Second / 600,
Accumulator: 0,
StepsCount: 0,
GravityForce: XY{0.0, -9.81},
Bodies: make([]*Body, 0),
Contacts: make([]*Contact, ... | func NewWorld(r io.ReaderAt) (w *World, err error) {
db, err := NewBTreeDB5(r)
if err != nil {
return
}
if db.Name != "World4" || db.KeySize != 5 {
return nil, ErrInvalidData
}
return &World{BTreeDB5: db}, nil
} | func NewWorld(title string, width, height int, scenes map[string]SceneFactory) (*World, error) {
w := float64(width)
h := float64(height)
cfg := pixelgl.WindowConfig{
Title: title,
Bounds: pixel.R(0, 0, w, h),
VSync: true,
Resizable: false,
}
window, err := pixelgl.NewWindow(cfg)
if err != ni... | func NewWorld(ball Ball, team Team) *World {
return &World{
Ball: ball,
Team: team,
}
} | func (wl WordList) Word() string {
return wl[rand.Intn(len(wl))]
} | func (dnmu *DuplicateNumberMessageUpdate) SetWorld(s string) *DuplicateNumberMessageUpdate {
dnmu.mutation.SetWorld(s)
return dnmu
} | func NewWorld(w int, healthy int, infected int) *World {
world := World{w, int(float64(w) * 2 / math.Sqrt(3)), make([]Agent, 0, 10)}
world.agents = append(world.agents, NewFoodSource(&world))
for i := 0; i < healthy; i++ {
world.agents = append(world.agents, NewTazzie(&world, false))
}
for i := 0; i < infected... | func Word() string {
return data.LoremIpsum[rand.Intn(len(data.LoremIpsum))]
} | func NewWorld(popSize, genes int) *World {
src := rand.NewSource(time.Now().UnixNano())
r := rand.New(src)
p := NewPopulation(popSize, genes)
return &World{r, genes, p, 0}
} | func (m *DuplicateNumberMessageMutation) SetWorld(s string) {
m.world = &s
} | func (fa FakeAdapter) Word() string {
return fake.Word()
} | func (fa FakeAdapter) Word() string {
return fake.Word()
} | func NewWorld(ligs []Light, objs []interface{}) *World {
w := &World{
Lights: ligs,
Objects: objs,
}
return w
} | func (d *Dispenser) Word() string {
if d.i > len(d.str) || d.i == 0 {
return ""
}
return strings.TrimSpace(d.str[d.i-1])
} | func (s *DescribeWorldInput) SetWorld(v string) *DescribeWorldInput {
s.World = &v
return s
} | func Word() string {
const options = 2 // # of enum options
s := getRandSource()
randLock.Lock()
n := s.Intn(options)
randLock.Unlock()
switch n {
case adjective:
return Adjective()
default:
return Noun()
}
} | func (o *Spatial) GetWorld() WorldImplementer {
//log.Println("Calling Spatial.GetWorld()")
// Build out the method's arguments
ptrArguments := make([]gdnative.Pointer, 0, 0)
// Get the method bind
methodBind := gdnative.NewMethodBind("Spatial", "get_world")
// Call the parent method.
// World
retPtr := gdna... | func NewWorld(game core.Game, o WorldOptions) *World {
// random positions in the world are seeded too
rnd := rand.New(rand.NewSource(o.Seed))
// create terrain
terrain := terrain.Generate(&terrain.Generator{
Seed: o.Seed,
Width: o.Width,
Height: o.Height,
Roughness: 7.5,
LowColor: o.LowColo... | func (w *World) String() string {
return fmt.Sprintf("Generation: %d\n%s\n", w.gen, w.current)
} | func (s *WorldConfig) SetWorld(v string) *WorldConfig {
s.World = &v
return s
} | func (server *Server) DefaultWorld() *world.World {
return server.World(server.worlds.def)
} | func New() *World {
return &World{
Network: network.New(),
ProcessesList: make([]*process.Process, 0),
Associates: make(map[string]process.WorkFunction),
}
} | func (LoremService) Word(min, max int) string {
return lorem.Word(min, max)
} | func NewWorld(Objects []spheres.Sphere, LightSources []lights.PointLight) World {
return World{Objects, LightSources}
} | func LoadWorld(filename string) (World, error) {
filename = strings.Trim(filename, "\n")
logger.Info("Loading world....", logger.Params{"filename": filename})
//open file.
file, err := os.Open(filename)
if err != nil {
return nil, err
}
defer file.Close()
// parse cities.
world := make(World)
scanner := b... | func GetWord() (string, error) {
address := fmt.Sprintf("%s:%v", cfg.Conf.Internets.Service.Host, cfg.Conf.Internets.Service.Port)
conn, err := grpc.Dial(address, grpc.WithInsecure())
if err != nil {
return "", fmt.Errorf("error while connecting: %v", err)
}
defer conn.Close()
c := wordgen.NewInternetsWordGener... | func (v *View) Word(x, y int) (string, error) {
x = v.ox + x
y = v.oy + y
if y < 0 || y >= len(v.lines) || x >= len(v.lines[y]) {
return "", errors.New("invalid point")
}
l := string(v.lines[y])
nl := strings.LastIndexFunc(l[:x], indexFunc)
if nl == -1 {
nl = 0
} else {
nl = nl + 1
}
nr := strings.Inde... | func CreateWarehouseWorld() *WarehouseWorld {
w := &WarehouseWorld{
simple.NewUndirectedGraph(),
make(map[common.RobotID]common.Robot),
task.CreateSimulatedTaskManager(),
}
for i := 1; i < 13; i++ {
w.graph.AddNode(simple.Node(i))
}
w.graph.SetEdge(w.graph.NewEdge(w.graph.Node(1), w.graph.Node(2)))
w.gr... | func (v *VerbalExpression) Word() *VerbalExpression {
return v.add(`\w+`)
} | func (l *lexer) word() string {
return l.line[l.start:l.pos]
} | func New(fs int, framePeriod float64) *World {
w := &World{
Fs: fs,
FramePeriod: framePeriod,
}
return w
} | func (m *DuplicateNumberMessageMutation) OldWorld(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, fmt.Errorf("OldWorld is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, fmt.Errorf("OldWorld requires an ID field in the mutation")
}
oldV... | func NewWorld(size int) *World {
slice := [][]int{}
for i := 0; i < size; i++ {
line := []int{}
for k := 0; k < size; k++ {
line = append(line, 0)
}
slice = append(slice, line)
}
return &World{
Size: size,
matrix: slice,
}
} | func (server *Server) LoadWorld(name string, system world.System, gen world.Generator, dimension world.Dimension) *world.World {
w := server.World(name)
if w != nil {
return w
}
server.worlds.Lock()
if w = server.worlds.m[name]; w != nil { //Double check now we have the lock
return w
}
wait, ok := server.wor... | func DefaultWorld() *World {
var lights []Light
var objects []interface{}
light := NewLight()
*light = light.PointLight(*Point(-10, 10, -10), *NewColor(1, 1, 1))
lights = append(lights, *light)
s1 := NewSphere()
s1.Mat.Col = *NewColor(0.8, 1.0, 0.6)
s1.Mat.Diffuse = 0.7
s1.Mat.Specular = 0.2
objects = appen... | func DefaultWorld() World {
light := lights.NewPointLight(tuples.Point(-10, 10, -10), colors.White())
s1 := spheres.NewUnitSphere()
s1.Material.Color = colors.NewColor(0.8, 1.0, 0.6)
s1.Material.Diffuse = 0.7
s1.Material.Specular = 0.2
s2 := spheres.NewUnitSphere()
s2.SetTransform(transformations.Scaling(0.5, ... | func (g GameWorld) Type() string {
return "GameWorld"
} | func (m Movie) Worldwide() float64 {
return m.Gross - m.Domestic
} | func NewGameWorld() *GameWorld {
gameWorld := &GameWorld{
Network{
Name: "Game World",
Port: global.GameWorldPort,
},
}
gameWorld.dataHandler = gameWorld.process
return gameWorld
} | func (body *Body) Local2World(v Vect) (Vect) {
return body.p.Add(v.Rotate(body.rot))
} | func (t *Token) GetWord() string {
return t.word
} | func (world *World) Dimension() Dimension {
return world.worldData.Dimension
} | func GenerateWorld(world [][]string, gridSpace, year int) {
dc := gg.NewContext(len(world)*gridSpace, len(world[0])*gridSpace)
tiles := model.LoadTilesImageSized(uint(gridSpace))
for x := 0; x < len(world); x++ {
fmt.Printf("World Generation: %v\n", float64(float64(x)/float64(len(world))))
for y := 0; y < len(wo... | func (o *Viewport) GetWorld() WorldImplementer {
//log.Println("Calling Viewport.GetWorld()")
// Build out the method's arguments
ptrArguments := make([]gdnative.Pointer, 0, 0)
// Get the method bind
methodBind := gdnative.NewMethodBind("Viewport", "get_world")
// Call the parent method.
// World
retPtr := g... | func Word(msg string) string {
fmt.Print(msg + " > ")
var text string
fmt.Scan(&text)
return Normalize(text)
} | func (w *World) String() string {
agentMap := make([][]byte, w.height)
for i := 0; i < len(agentMap); i++ {
agentMap[i] = make([]byte, w.width)
for j := 0; j < len(agentMap[i]); j++ {
agentMap[i][j] = '.'
}
}
for _, a := range w.agents {
r, c := a.Position()
if r >= 0 && r < w.height && c >= 0 && c < ... | func NewWorld(worldMap *Map, n int) World {
aliens := createRandomAliens(worldMap, n)
// Initialize distribution for aliens.
distribution := make(map[string][]*Alien)
wi := &worldImp{
Aliens: aliens,
WorldMap: worldMap,
Distribution: distribution,
}
wi.updateDistribution()
wi.fightAliens()
ret... | func (w *World) Generation() int {
return w.gen
} | func (p *HelloUniverse) RegisterWorld(name string, size int) {
p.worlds[name] = size
log.Printf("World %s (size %d) was registered", name, size)
} | func NewWorld(noRooms int, roomSize int) World {
var w World
for noRow := 0; noRow < noRooms/2; noRow++ {
for noColumn := 0; noColumn < 2; noColumn++ {
room := NewRoom(
Dimensions{
X1: (roomSize * noRow),
Y1: (roomSize * noColumn),
X2: roomSize + (roomSize * noRow),
Y2: roomSize + (roomSi... | func (self *PhysicsP2RotationalSpring) World() *PhysicsP2{
return &PhysicsP2{self.Object.Get("world")}
} | func NewWorld(dir string) (*World, error) {
players, err := listUsers(dir)
if err != nil {
return nil, fmt.Errorf("app.main.NewWorld: %s", err)
}
iconBase64 := ""
bytes, err := ioutil.ReadFile(path.Join(dir, "icon.png"))
if err != nil {
iconBase64 = ""
}
iconBase64 = base64.StdEncoding.EncodeToString(bytes... | func (self *BitmapText) World() *Point{
return &Point{self.Object.Get("world")}
} | func New(opts *Options) *World {
if opts == nil {
opts = &Options{}
}
w := &World{
logger: opts.Logger,
leftDelim: opts.LeftDelim,
rightDelim: opts.RightDelim,
insecure: opts.Insecure,
}
if w.logger == nil {
w.logger = logrus.New()
}
return w
} | func (wm *WorldManager) FindWorld(id byte) context.WorldHandler {
for _, v := range wm.Worlds {
if v.Id == id {
return v
}
}
return nil
} | func HelloWorld(who, language string) string {
if who == "" {
who = "world"
}
return getPrefix(language) + who
} | func (s *VegState) ExamineWorld(m Mob, l *Level) MobState {
return &SearchState{
Pattern: m.SearchPattern(),
targetPointIdx: 0,
path: []twodee.GridPoint{},
pathIdx: 0,
pathAge: maxPathAge,
BaseState: &BaseState{"Search"}}
} | func (kw *Keyword) GetWord() string {
return kw.word
} | func (result *TranslationResult) GetWord() string {
return result.Word
} | func (psql PGX) GetOneRandomWorld(w *World) error {
var err error
queryID := rand.Intn(worldsCount) + 1
if err = psql.db.QueryRow("selectStmt", queryID).Scan(&w.ID, &w.RandomNumber); err != nil {
err = fmt.Errorf("error scanning world row with ID %d: %s", queryID, err)
}
return err
} | func ParseWorld(input string) World {
w := World{}
for y, row := range strings.Split(strings.TrimSpace(input), "\n") {
for x, raw := range row {
kind, ok := RuneKinds[raw]
if !ok {
kind = KindBlocker
}
w.SetTile(&Tile{
Kind: kind,
}, x, y)
}
}
return w
} | func (s *SeedEnc) Words(lang string) (string, er.R) {
wd, ok := allWords[lang]
if !ok {
return "", er.Errorf("Language [%s] is not supported", lang)
}
words := make([]string, 0, wordCount)
defer zeroStr(words)
b := big.NewInt(0)
defer zero.BigInt(b)
b_ := big.NewInt(0)
defer zero.BigInt(b_)
b2047 := big.New... | func (self *Lorem) Word(min, max int) string {
n := self.intRange(min, max)
return self.word(n)
} | func (occurence Occurence) GetWord() string {
return occurence.Word
} | func WorldRank() (rank int) {
var r int32
C.MPI_Comm_rank(C.World, (*C.int)(unsafe.Pointer(&r)))
return int(r)
} | [
"0.73961955",
"0.7078516",
"0.70608044",
"0.704096",
"0.70377123",
"0.6926203",
"0.68192744",
"0.66385084",
"0.66139096",
"0.6545688",
"0.6507795",
"0.64752394",
"0.64699525",
"0.63772744",
"0.6356447",
"0.6352053",
"0.63135993",
"0.6284382",
"0.62530553",
"0.61733997",
"0.61... |
Init Initializes the SecurityProfile informer | func (spi *SecurityProfileInformer) Init(nsp model.NSPInterface) error {
spi.Nsp = nsp
var err error
// Init stopper
spi.Stopper = make(chan struct{})
// Create custom CRD in k8s if it doesn't exist yet
if err = v1.CreateSecurityProfileCRD(nsp.GetKubeConfig()); err != nil {
return err
}
informerLogger.Debug("... | func (p *DummyProfile) Init() error {
return nil
} | func (userInfo *UserInfo) Init() error {
return nil
} | func (f *FieldProfile) Init() {
f.MinInt = make(map[string]int64)
f.MaxInt = make(map[string]int64)
f.MinLen = make(map[string]int64)
f.MaxLen = make(map[string]int64)
f.Default = make(map[string]string)
f.Enum = make(map[string][]string)
f.EnumHints = make(map[string]map[string]string)
f.DocStrings = make(map[... | func ProfileInit(cmd *cobra.Command, args []string) error {
// Try to load the profile.
if len(Conf.Profiles) == 0 {
return fmt.Errorf("please create a configuration profile to proceed")
}
p, name, err := Conf.SelectProfile()
if err != nil {
return fmt.Errorf("cannot select unknown profile %q", name)
} else ... | func (rcs *ResourceCallerStats) Init(){
rcs.mutex.Lock()
defer rcs.mutex.Unlock()
rcs.SuccessMap = make(map[string]int64)
rcs.FailedMap = make(map[string]int64)
} | func (identity *IotPeerData) Init() {
identity.HumanName = names.GetRandomName(10)
identity.MACaddress = identity.GetMac()
identity.IPFSaddress = identity.GetIPFS()
identity.PublicKey = identity.GetPublicKey()
identity.Serial = identity.GetSerial()
identity.TorAddress = identity.GetTorAddress()
identity.Alternat... | func (c *AuthConf) Init() error {
// only for development
c.Host = ""
c.SSMHost = ""
return nil
} | func (c *PodCheck) Init(cfg *config.AgentConfig, info *model.SystemInfo) {
c.sysInfo = info
} | func (p Proficiencies) Init() tea.Cmd {
return nil
} | func (p *provider) Init(ctx servicehub.Context) error {
return nil
} | func (auth Authorize) Init(jwt *signer.JWTSigner, db *db.MySQL, emailer *email.Emailer) *Authorize {
auth.DB = db
auth.Sign = jwt
auth.Emailer = emailer
return &auth
} | func Init(portalProxy interfaces.PortalProxy) (interfaces.StratosPlugin, error) {
return &UserInfo{portalProxy: portalProxy}, nil
} | func (user *ObjectStorageUser) Init(stack utils.StackInterface) {
user.ResourceBase.Init(stack)
user.setDelegate(user)
} | func (t *SpringbootAnalyser) Init(tc transformertypes.Transformer, env *environment.Environment) (err error) {
t.Config = tc
t.Env = env
return nil
} | func (p *Prospector) Init() error {
var prospectorer Prospectorer
var err error
switch p.config.InputType {
case cfg.StdinInputType:
prospectorer, err = NewProspectorStdin(p)
case cfg.LogInputType:
prospectorer, err = NewProspectorLog(p)
default:
return fmt.Errorf("Invalid input type: %v", p.config.InputT... | func (IndigoIAMConfig) Init() error {
return fmt.Errorf("Operation not implemented")
} | func (p *Provider) Init(ctx context.Context) error {
return nil
} | func (m *StatManager) Init(polProv policy.Provider, leaseProv lease.Provider) error {
stats, err := m.collect(polProv, leaseProv, false)
if err != nil {
return err
}
m.last = stats
return nil
} | func (d *Device) Init(profile DeviceProfile) error {
if err := d.sanityCheck(false); err != nil {
return err
}
d.active = true
d.closed = make(chan struct{})
d.messages = make(chan *sms.Message, 100)
d.ussd = make(chan Ussd, 100)
d.updated = make(chan struct{}, 100)
d.Commands = profile
return profile.Init(d... | func (f *basicAuthorizer) Init() error {
return nil
} | func (provider *DNSProvider) Init(conf *settings.Settings) {
provider.configuration = conf
} | func (m *Monitor) Init(nsp model.NSPInterface) error {
m.eventStreamMaxRetries = 5
m.Nsp = nsp
m.wg = nsp.GetWaitGroup()
m.config = nsp.GetConfig()
m.collection = nsp.GetCollection()
// Prepare Docker client
var err error
m.Client, err = godocker.NewEnvClient()
if err != nil {
return err
}
m.EventsContext,... | func (p *AWS) Init(config Config) (err error) {
switch {
case p.Type == "":
return errors.New("provisioner type cannot be empty")
case p.Name == "":
return errors.New("provisioner name cannot be empty")
case p.InstanceAge.Value() < 0:
return errors.New("provisioner instanceAge cannot be negative")
}
// Add... | func (o *OIDC) Init(config Config) (err error) {
switch {
case o.Type == "":
return errors.New("type cannot be empty")
case o.Name == "":
return errors.New("name cannot be empty")
case o.ClientID == "":
return errors.New("clientID cannot be empty")
case o.ConfigurationEndpoint == "":
return errors.New("con... | func Init() {
setKeys()
setRegisteredAddress()
} | func (p *Provider) Init(_ types.Constraints) error {
if p.ACMELogging {
legolog.Logger = fmtlog.New(log.WriterLevel(logrus.InfoLevel), "legolog: ", 0)
} else {
legolog.Logger = fmtlog.New(ioutil.Discard, "", 0)
}
if p.Store == nil {
return errors.New("no store found for the ACME provider")
}
var err error... | func (s Std) Init(params ...interface{}) *er.Error {
return nil
} | func Init(profile, configDir string, logLevel LogLevel) {
setLogLevel(logLevel)
logMessage(INFO, fmt.Sprintf("Profile: %s", profile))
logMessage(INFO, fmt.Sprintf("Configuration directory: %s", configDir))
//add a trailing slash to config directory
if configDir != "" {
logMessage(WARN, fmt.Sprintf("adding a tr... | func (client *Client) InitMyProfile(fieldArgs ...string) *Error {
users, err := client.UsersInfo(Destination{}, fieldArgs...)
if err != nil {
return err
}
if len(users) == 0 {
return NewError(ErrBadCode, "An unexpected error occurred.")
}
client.VKUser.Me = users[0]
return nil
} | func Init() {
InitUsers()
InitEvents()
} | func (p *AWSProvider) Init(args []string) error {
p.region = args[0]
p.profile = args[1]
// Terraformer accepts region and profile configuration, so we must detect what env variables to adjust to make Go SDK rely on them. AWS_SDK_LOAD_CONFIG here must be checked to determine correct variable to set.
enableSharedCo... | func (m *SpannerDatabaseIAMMember) Init(string) error {
return nil
} | func Init() {
initOnce.Do(initFairyInfo)
} | func (ap *AgentProvider) Init() error {
ap.pid = strconv.Itoa(os.Getpid())
gosdk.Init()
return nil
} | func (p *Azure) Init(config Config) (err error) {
switch {
case p.Type == "":
return errors.New("provisioner type cannot be empty")
case p.Name == "":
return errors.New("provisioner name cannot be empty")
case p.TenantID == "":
return errors.New("provisioner tenantId cannot be empty")
case p.Audience == "": ... | func (perf *Perf) Init(name string, proc ecs.Proc) {
const timeFormat = "20060102T150405Z0700"
perf.profDebug = 2
perf.Proc = proc
if nowf := time.Now().Format(timeFormat); name == "" {
perf.outputBase = fmt.Sprintf("prof-%s", nowf)
} else {
perf.outputBase = fmt.Sprintf("%s-prof-%s", name, nowf)
}
} | func (provider *DNSProvider) Init(conf *settings.Settings) {
provider.configuration = conf
provider.API = URL
} | func Init() {
fileProviderByIssuer = make(map[string]model.Provider)
for _, p := range config.Get().Providers {
iss0, iss1 := issuerutils.GetIssuerWithAndWithoutSlash(p.Issuer)
fileProviderByIssuer[iss0] = SimpleProvider{p}
fileProviderByIssuer[iss1] = SimpleProvider{p}
}
} | func (spc *InsuranceContract) InitInsurance(ctx contractapi.TransactionContextInterface) error {
defaultFSABalance = 1000
// possible function to pre create policy and then create plans. then add the plans to the policy array.
accountCount = 0
userCount = 0
planCount = 0
policyCount = 0
return nil
} | func (as *AccessServer) Init(setting framework.Setting) {
as.setting = setting
} | func (m *SpannerInstanceIAMMember) Init(string) error {
return nil
} | func init() {
addCheck(CheckAppArmorProfile)
} | func Init() error {
overlayConfig()
return AutoLoginDefault()
} | func InitSecurityLevel(algorithm string, level int) (err error) {
initOnce.Do(func() {
err = SetSecurityLevel(algorithm, level)
})
return
} | func (i *localInitializer) Initialize(plugin admission.Interface) {
if wants, ok := plugin.(WantsSecurityInformer); ok {
wants.SetSecurityInformers(i.sccInformer)
}
} | func (s *Backend) Init(parameters map[string]interface{}, credentials []byte) error {
var err error
s.SecretsManager = SecretManagerClient{}
s.session, err = utils.GetAWSSession(parameters, credentials, defaultRegion)
if err != nil {
return err
}
var ok bool
table, ok = parameters["table"].(string)
if !ok {
... | func (t *policyChaincode) Init(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {
adminCert := args[0]
fmt.Println("This is the adminCert: " + adminCert)
if len(adminCert) == 0 {
fmt.Println("This is the adminCert: " + adminCert)
return nil, errors.New("Invalid admin certificate,... | func (p *dummyProvider2) Init(name string, _ *config.Config, _ log.Loggerer) error {
return fmt.Errorf("aah/cache: provider %s init error", name)
} | func (p *dummyProvider) Init(name string, _ *config.Config, _ log.Loggerer) error { return nil } | func (supervisor *CoreSourceLifeSupervisor) Init() {
// Your initialization code here
} | func init() {
var usr1 []string
var usr2 []string
var out string
usr1EnvStr := os.Getenv(`USR1_PROF`)
if usr1EnvStr == "" {
usr1EnvStr = "goroutine"
}
usr1 = strings.Split(usr1EnvStr, ",")
usr2EnvStr := os.Getenv(`USR2_PROF`)
if usr2EnvStr == "" {
usr2EnvStr = "heap"
}
usr2 = strings.Split(usr2EnvStr... | func (s *AWSS3) Init(metadata bindings.Metadata) error {
m, err := s.parseMetadata(metadata)
if err != nil {
return err
}
uploader, err := s.getClient(m)
if err != nil {
return err
}
s.metadata = m
s.uploader = uploader
return nil
} | func (ls *LoginSystem) Init() {
ls.loginEvents = make(chan eb.Event, 128)
eb.Subscribe(eb.S_LOGIN, ls.loginEvents)
eb.Subscribe(eb.S_LOGOUT, ls.loginEvents)
// Set up for player list singleton management
ls.sidsToEnts = make(map[float64]*entities.PlayerE)
ls.sa.SetPlayerListSingleton(ls.sidsToEnts)
} | func (dc *DomainCertificate) Init() error {
tlsCert, err := dc.tlsCert()
if err != nil {
return err
}
dc.TLSCert = tlsCert
return nil
} | func Init() error {
var err error
if err := initMetrics(); err != nil {
return err
}
conf, err = getConfig()
if err != nil {
return fmt.Errorf("Could not obtain configuration from registry. %v", err)
}
elog.Info(201, fmt.Sprintf(
"Application configured from registry.\n\n"+
"Domain: %v\n"+
"Svc name... | func Init(config *utils.Config) {
// nothing to do here
} | func Init(config utils.Config, lid, URL string, transport int) {
AuthSession.User = config.User
AuthSession.Pass = config.Pass
AuthSession.Email = config.Email
AuthSession.Insecure = config.Insecure
AuthSession.LID = lid
AuthSession.CookieJar, _ = cookiejar.New(nil)
if transport == HTTP {
AuthSession.URL, _ = ... | func (s *JwtSigner) Init(alg jose.SignatureAlgorithm, signingKey interface{}) error {
var err error
s.signer, err = jose.NewSigner(jose.HS256, signingKey)
return err
} | func (f *ConsensusMechanism) Init(tangle *tangle.Tangle) {
f.tangle = tangle
f.Storage = NewStorage(tangle.Options.Store)
} | func Init(user, pass, server string) {
rpcConf = config.New(user, pass, server)
callId = 0
} | func Init() *DigiSecurity {
return &DigiSecurity{
soap.NewClient(),
}
} | func Init(sess client.ConfigProvider) {
if err := loadConfig(); err != nil {
fmt.Println("Unable to loadConfig:", err)
return
}
snsSvc = sns.New(sess)
sqsSvc = sqs.New(sess)
stsSvc = sts.New(sess)
if err := getCallerIdentity(); err != nil {
fmt.Println("Unable to getCallerIdentity:", err)
return
}
i... | func (pc *PrometheusCheck) Init(version int) error {
pc.initInstances(version)
return pc.initAD()
} | func Init() error {
config = &Config{
Friends: make([]*Friend, 0),
Port: "8080",
Name: "anon",
}
save = saveConfig
return readConfig()
} | func Init() *SshClientInfo {
fmt.Println("Creating Ssh Main init")
return &SshClientInfo{SshInfo: make(map[string]*ClientInfo)}
} | func (a *AwsContext) Init() error {
err := checkEnvVars()
if err != nil {
return fmt.Errorf("Init fail: %w", err)
}
a.session, err = session.NewSession(&aws.Config{})
if err != nil {
return fmt.Errorf("Error initializing AWS Session: %w", err)
}
a.ec2 = ec2.New(a.session)
a.SetOwnerIDFromEnv()
a.SetSecur... | func (sm *SubscriptionManager) Init(mgr manager.Manager) error {
if len(sm.envCfg.URL) == 0 {
return xerrors.Errorf("env var URL must be a non-empty value")
}
sm.mgr = mgr
sm.namedLogger().Info("initialized JetStream subscription manager")
return nil
} | func (ths *AsetBalances) Init(id string, ks []string, v ...interface{}) {
ths.BaseUserInfo.Init(id, ks...)
ths.Proxy = nt.GetInitProxy(v...)
ths.Values = make(map[string]float64)
} | func (p *Provider) Initialize(cfg *config.Config, log *logrus.Entry) {
p.cfg = cfg
p.log = log.WithFields(logrus.Fields{"provider": "external"})
p.paths = map[string]string{}
} | func (r *RecordManager) Init() error {
r.log.Debug("Configuring...")
if err := r.ensureHostedZone(); err != nil {
return err
}
r.log.Info("init is done")
return nil
} | func (g *Backend) Init(parameters map[string]string) error {
ctx := context.Background()
g.projectID = parameters["projectID"]
sAccount := serviceAccount{}
jsonCredentials, err := sAccount.Marshal(parameters)
println(string(jsonCredentials))
if err != nil {
log.Info("here")
return err
}
config, err := goo... | func (spi *SecurityProfileInformer) Start() error {
go spi.Informer.Informer().Run(spi.Stopper)
informerLogger.Debug("SecurityProfile informer started")
return nil
} | func (t *ReadMeGenerator) Init(tc transformertypes.Transformer, env *environment.Environment) (err error) {
t.Config = tc
t.Env = env
return nil
} | func (h *UsecaseEvent) Init(ctx context.Context, data interface{}) error {
return nil
} | func Init(cfg *DBConfig) error {
log.Debug("--------------------Initializing Config-------------------")
log.Debug("-----------------------END Config metrics----------------------")
return nil
} | func Init(cfg *DBConfig) error {
log.Debug("--------------------Initializing Config-------------------")
log.Debug("-----------------------END Config metrics----------------------")
return nil
} | func (vs *VolumeSnapshotter) Init(config map[string]string) error {
clusterConfig, err := rest.InClusterConfig()
if err != nil {
return fmt.Errorf("Error to retrieve in cluster config: %v", err)
}
kClient, err := kubernetes.NewForConfig(clusterConfig)
if err != nil {
return fmt.Errorf("Error to retrieve kubern... | func (i *IAMPolicy) Init(*Project) error {
if i.Name() == "" {
return errors.New("name must be set")
}
return nil
} | func (p *ProcessCheck) Init(_ *config.AgentConfig, info *model.SystemInfo) {
p.sysInfo = info
p.notInitializedLogLimit = util.NewLogLimit(1, time.Minute*10)
networkID, err := agentutil.GetNetworkID(context.Background())
if err != nil {
klog.Infof("no network ID detected: %s", err)
}
p.networkID = networkID
} | func (ms *ProjectIAMMembers) Init(projectID string) error {
ms.project = projectID
return nil
} | func (m *Manager) Init() error {
if m.storage == nil {
return errors.New("missing storage interface")
}
if m.config == nil {
return errors.New("missing config")
}
list := m.storage.GetCa()
switch len(list) {
case 0:
key, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return err
}
cert, ... | func (s *PrometheusSink) Init(cluster string, cluster_conf clusterConf, args []string, sd map[string]statDetail) error {
var username, password string
authenticated := false
// args are either nothing, or, optionally, a username and password to support basic auth on the metrics endpoint
switch len(args) {
case 0:
... | func (r *runner) Init(ctx context.Context) error {
err := r.runner.Init(ctx)
if err != nil {
return fmt.Errorf("error running terraform init: %w", err)
}
return nil
} | func (p *App) Init() error {
logrus.WithFields(logrus.Fields{
"name": p.Name(),
"version": p.Version().String(),
}).Info("App Provider initialized")
return nil
} | func (a *InstanceAccess) Init(scope scope.Scope, retry time.Duration) error {
return a.InstanceObserver.Init(scope, retry)
} | func (p *provider) Init(sid string, expires time.Duration) *Session {
newSession := p.newSession(sid, expires)
p.mu.Lock()
p.sessions[sid] = newSession
p.mu.Unlock()
return newSession
} | func (ku *Upgrader) Init(translator *i18n.Translator, logger *logrus.Entry, clusterTopology ClusterTopology, client armhelpers.ACSEngineClient, kubeConfig string) {
ku.Translator = translator
ku.logger = logger
ku.ClusterTopology = clusterTopology
ku.Client = client
ku.kubeConfig = kubeConfig
} | func Init(issuer string, k []byte) error {
localIssuer = issuer
var err error
signingKey, err = jwt.ParseRSAPrivateKeyFromPEM(k)
if err != nil {
return sdk.WithStack(err)
}
verifyKey = &signingKey.PublicKey
return nil
} | func (c *ConnectionsCheck) Init(cfg *config.AgentConfig, sysInfo *model.SystemInfo) {
} | func (g *Backend) Init(parameters map[string]string) error {
ctx := context.Background()
if len(parameters) == 0 {
return fmt.Errorf("invalid or empty Config")
}
projectID, ok := parameters["projectID"]
if !ok {
return fmt.Errorf("invalid parameters")
}
g.projectID = projectID
sAccount := serviceAccount... | func (c *UniversityControllerImpl) Init(
config *rest.Config,
si *sharedinformers.SharedInformers,
queue workqueue.RateLimitingInterface) {
// Get the informer and lister for subscribing to university events and querying universities from
// the lister cache
i := si.Factory.Miskatonic().V1beta1().Universities()
... | func (etherscan *Etherscan) Init(baseURL, apiKey string) {
etherscan.BaseURL = baseURL
etherscan.APIKey = apiKey
} | func (sb *RoarBitmap) Init() error {
sb.passportData = make([]*roaring.Bitmap, passportSeries)
return nil
} | func Init() error {
state = new(jwtState)
state.tokenAuth = jwtauth.New("HS256", []byte("fdsfvsdvsvxcvxfgsdgsdfgsd"), nil)
return nil
} | func Init(name string, cfg *types.Chain33Config, sub []byte) {
drivers.Register(cfg, GetName(), newPrivacy, cfg.GetDappFork(driverName, "Enable"))
// 如果需要在开发环境下使用隐私交易，则需要使用下面这行代码，否则用上面的代码
//drivers.Register(newPrivacy().GetName(), newPrivacy, 0)
InitExecType()
} | func (sr *SampleRouter) Init(){
// Guard against re-initialization. Only initialize a new map on creation
if !sr.isInitted(){
sr.throttler = make(map[string]ratelimiter.RateLimit)
sr.throttlerMtx = sync.Mutex{}
}
} | func (terraformer *Terraformer) Init() error {
success, err := terraformer.RunStreamed("init",
"-input=false", // non-interactive
"-no-color",
terraformer.LockFlag,
)
if err != nil {
return err
}
if !success {
return errors.New("failed to execute 'terraform init'")
}
return nil
} | func (a *AppIperf) Init(cfg app.AppConfig) {
a.app_id = cfg.AppID
a.interest_map = make(common.InterestMap)
utils.JSONToStruct(cfg.Config, &a.cfg)
a.tasks = utils.LoadTasksFromFile(a.cfg.TaskPath)
a.populate_im()
} | func Init(issuer string, k []byte) error {
IssuerName = issuer
var err error
signingKey, err = jwt.ParseRSAPrivateKeyFromPEM(k)
if err != nil {
return sdk.WithStack(err)
}
verifyKey = &signingKey.PublicKey
return nil
} | func (s *Sensor) Init() {
s.metrics = make([]string, 0)
s.lastMessages = make(map[string]*DisplayMessage)
s.Wrap = false
s.Title = "Sensors"
} | [
"0.72643477",
"0.6852993",
"0.6446654",
"0.6398271",
"0.62689257",
"0.62124586",
"0.61981773",
"0.6134021",
"0.6094902",
"0.6066088",
"0.6060321",
"0.6041276",
"0.6038694",
"0.6004886",
"0.5975346",
"0.5958717",
"0.595679",
"0.5955895",
"0.594505",
"0.59374017",
"0.5921807",
... |
Start Starts the SecurityProfile informer | func (spi *SecurityProfileInformer) Start() error {
go spi.Informer.Informer().Run(spi.Stopper)
informerLogger.Debug("SecurityProfile informer started")
return nil
} | func StartProfile(w io.Writer) error {
err := globalProfiler.p.start()
if err != nil {
return err
}
globalProfiler.w = w
atomic.StoreInt32(&globalProfiler.enabled, 1)
return nil
} | func StartProfile(p *Profiler, key string) {
if p == nil {
return
}
p.StartProfile(key)
} | func StartProfile(typ string) (string, error) {
f, ok := pm[typ]
if !ok {
return "", fmt.Errorf("Unknown profile: %s", typ)
}
select {
case pmChan[typ] <- struct{}{}:
defer func() { <-pmChan[typ] }()
default:
return "", fmt.Errorf("Profiling is already running: %s", typ)
}
fname := fmt.Sprintf("%s_%v.ppr... | func profilestartcmd() {
var profileFlags string
if daemonCPUProfile {
profileFlags += "c"
}
if daemonMemoryProfile {
profileFlags += "m"
}
if daemonTraceProfile {
profileFlags += "t"
}
if profileFlags == "" {
die("no profiles submitted")
}
err := httpClient.DaemonStartProfilePost(profileFlags, daemon... | func (s *Service) Start() error {
if s.options.cpuProfile != "" {
f, err := os.Create(s.options.cpuProfile)
if err != nil {
return err
}
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for sig := range c {
glog.Err... | func (p *Profiler) Start() error {
if p.Dir == "" {
if p.ProfileCPU {
return errors.New("-profile-cpu requires -profile-output-dir to be set")
}
if p.ProfileHeap {
return errors.New("-profile-heap requires -profile-output-dir to be set")
}
}
if p.ProfileCPU {
out, err := os.Create(p.generateOutPath("... | func (s *Server) StartProfiler() {
s.log.Infof("Starting profiling on http port %d", s.opts.ProfPort)
hp := fmt.Sprintf("%s:%d", s.opts.HostName, s.opts.ProfPort)
go func() {
err := http.ListenAndServe(hp, nil)
if err != nil {
s.log.Emergencyf("Error starting profile monitoring service: %s", err)
}
}()
} | func (s *Server) StartProfiler() {
s.log.Infof("Starting profiling on http port %d", s.opts.ProfPort)
hp := fmt.Sprintf("%s:%d", s.info.Hostname, s.info.ProfPort)
go func() {
err := http.ListenAndServe(hp, nil)
if err != nil {
s.log.Emergencyf("Error starting profile monitoring service: %s", err)
}
}()
} | func (s *profilingServer) start(ctx context.Context) {
if s.cfg.profilingServer.mode == "gcp" {
name := s.cfg.meta.serviceName
if prfx := s.cfg.profilingServer.gcpServicePrefix; prfx != "" {
name = prfx + "-" + name
}
if err := profiler.Start(profiler.Config{
Service: name,
ServiceVersion: s... | func (spi *SecurityProfileInformer) Init(nsp model.NSPInterface) error {
spi.Nsp = nsp
var err error
// Init stopper
spi.Stopper = make(chan struct{})
// Create custom CRD in k8s if it doesn't exist yet
if err = v1.CreateSecurityProfileCRD(nsp.GetKubeConfig()); err != nil {
return err
}
informerLogger.Debug("... | func (p *GlusterVolumeService) StartProfile() *GlusterVolumeServiceStartProfileRequest {
return &GlusterVolumeServiceStartProfileRequest{GlusterVolumeService: p}
} | func startProfile(cpuprofile, memprofile string) {
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Errorf("cpuprofile: %s", err)
}
log.Info("writing CPU profile to: %s\n", cpuprofile)
prof.cpu = f
pprof.StartCPUProfile(prof.cpu)
}
if memprofile != "" {
f, err := os.Create(... | func (perf *Perf) Start() { perf.shouldProfile = true } | func startProfile(cpuprofile, memprofile string) {
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Fatalf("cpuprofile: %v", err)
}
log.Printf("writing CPU profile to: %s\n", cpuprofile)
prof.cpu = f
pprof.StartCPUProfile(prof.cpu)
}
if memprofile != "" {
f, err := os.Creat... | func StartProfiler() {
go func() {
console.PrintInterface(console.LevelInfo, http.ListenAndServe("localhost:6060", nil))
}()
} | func (h *HandlerT) StartCPUProfile(file string) error {
h.mu.Lock()
defer h.mu.Unlock()
if h.cpuW != nil {
return errors.New("CPU profiling already in progress")
}
f, err := os.Create(expandHome(file))
if err != nil {
return err
}
if err := pprof.StartCPUProfile(f); err != nil {
f.Close()
return err
}
... | func (a *Aperture) Start(errChan chan error) error {
// Start the prometheus exporter.
err := StartPrometheusExporter(a.cfg.Prometheus)
if err != nil {
return fmt.Errorf("unable to start the prometheus "+
"exporter: %v", err)
}
// Enable http profiling and validate profile port number if requested.
if a.cfg... | func (p *profiler) Start() {
path, err := os.MkdirTemp("", "profile")
if err != nil {
p.logger.Fatal("Could not create initial output directory: %v", err)
}
// create a pprof file for the mode
fn := filepath.Join(path, string(p.mode)+".pprof")
f, err := os.Create(fn)
if err != nil {
p.logger.Fatal("Could no... | func (self *app) startCpuProfile(cpuprofile string) error {
f, err := os.Create(cpuprofile)
if err != nil {
return fmt.Errorf("Failed to create CPU profile: %v", err)
}
pprof.StartCPUProfile(f)
// Handle
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
go func() {
for sig := range c {
log.Info... | func (a *AuditConfig) Start() {
} | func Start(profile string) error {
if runtime.GOOS == "windows" {
return fmt.Errorf("starting an SSH agent on Windows is not yet supported")
}
cc, err := config.Load(profile)
if err != nil {
return fmt.Errorf("failed loading config: %v", err)
}
running, err := isRunning(cc)
if err != nil {
return fmt.Error... | func (p *profiling) Start() {
if atomic.AddInt32(&p.started, 1) > 1 {
return
}
if len(p.blockName) > 0 || len(p.httpAddr) > 0 {
runtime.SetBlockProfileRate(p.blockRate)
}
if len(p.mutexName) > 0 || len(p.httpAddr) > 0 {
runtime.SetMutexProfileFraction(p.mutexRate)
}
if len(p.cpuName) > 0 {
p.startCPU()
... | func startProfileIfSupported(b *testing.B, env *regtest.Env, name string) func() {
if !env.Editor.HasCommand(command.StartProfile.ID()) {
return nil
}
b.StopTimer()
stopProfile := env.StartProfile()
b.StartTimer()
return func() {
b.StopTimer()
profFile := stopProfile()
totalCPU, err := totalCPUForProfile(... | func (receiver *adminRPCReceiver) StartProfiling(args *StartProfilingArgs, reply *VoidReply) error {
return receiver.local.StartProfiling(args.Profiler)
} | func StartCPUProfile(profileDir, identifier string) error {
// Lock the cpu profile lock so that only one profiler is running at a
// time.
cpuLock.Lock()
if cpuActive {
cpuLock.Unlock()
return errors.New("cannot start cpu profilier, a profiler is already running")
}
cpuActive = true
cpuLock.Unlock()
// St... | func (sm *Statemgr) OnSecurityProfileCreateReq(nodeID string, objinfo *netproto.SecurityProfile) error {
return nil
} | func startProfiling() {
var err error
// if we've passed in filenames to dump profiling data too,
// start collecting profiling data.
if memProfile != "" {
runtime.MemProfileRate = 1
}
if cpuProfile != "" {
var f *os.File
if f, err = os.Create(cpuProfile); err != nil {
log.Fatal(err)
}
pprof.StartCPU... | func startProfiling() {
var err error
// if we've passed in filenames to dump profiling data too,
// start collecting profiling data.
if memProfile != "" {
runtime.MemProfileRate = 1
}
if cpuProfile != "" {
var f *os.File
if f, err = os.Create(cpuProfile); err != nil {
log.Fatal(err)
}
pprof.StartCPU... | func (state *profilingState) start(ctx context.Context, logger Logger, metadata io.Reader) {
// The state.duration field may be updated after the goroutine starts,
// by the caller, so it must be read outside the goroutine.
duration := state.duration
go func() {
defer func() { state.finished <- struct{}{} }()
i... | func StartCPUProfile(w io.Writer, hz uint32) error {
// The runtime routines allow a variable profiling rate,
// but in practice operating systems cannot trigger signals
// at more than about 500 Hz, and our processing of the
// signal is not cheap (mostly getting the stack trace).
// 100 Hz is a reasonable choice... | func startProfiling(profile profName) (profilesDirectory string, err error) {
switch profile {
case profileCPU, profileTrace, profileGoroutine, profileThreadcreate, profileHeap, profileBlock, profileAll: // ok
default:
return "", fmt.Errorf("unknown profile: '%v'", profile)
}
return doStartProfiling(profile, def... | func (sp *StakingProcessor) Start() error {
sp.Logger.Info("Starting")
return nil
} | func runSeccompAdvisorStart(cmd *cobra.Command, args []string) error {
if params.Podname == "" {
return commonutils.WrapInErrMissingArgs("--podname")
}
traceOutputMode, err := outputModeToTraceOutputMode(outputMode)
if err != nil {
return err
}
if traceOutputMode != gadgetv1alpha1.TraceOutputModeExternalRes... | func (adh *AdminHandler) startRequestProfile(scope int) tally.Stopwatch {
adh.startWG.Wait()
sw := adh.metricsClient.StartTimer(scope, metrics.CadenceLatency)
adh.metricsClient.IncCounter(scope, metrics.CadenceRequests)
return sw
} | func StartProfiler() {
// runtime.MemProfileRate = mpr
log.Println(http.ListenAndServe("localhost:6061", nil))
//runtime.SetBlockProfileRate(100000)
} | func (api *API) StartCPUProfileHandler(resp http.ResponseWriter, req *http.Request) {
if api.CPUProfile != "" {
f, err := os.Create(api.CPUProfile)
if err != nil {
http.Error(resp,
fmt.Sprintf("Unable to create CPU profile : %s", err.Error()),
http.StatusInternalServerError)
log.WithError(err).
E... | func (s *Service) start() error {
if s.running {
return nil
}
log.Info("starting instrumentation service...")
s.createHTTP()
s.startJaegerExporter()
s.startPrometheusExporter()
if err := s.registerGrpcViews(); err != nil {
s.stopJaegerExporter()
s.stopPrometheusExporter()
s.closeHTTP()
return err
}... | func (pc Controller) Start(c *gin.Context) {
var sessioninfo entity.SessionInfo
log.Println(sessioninfo.ID)
c.HTML(http.StatusOK, "start.html", gin.H{})
} | func StartProfiling(logger moira.Logger, config ProfilerConfig) {
pprofMux := http.NewServeMux()
pprofMux.HandleFunc("/debug/pprof/", pprof.Index)
pprofMux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
pprofMux.HandleFunc("/debug/pprof/profile", pprof.Profile)
pprofMux.HandleFunc("/debug/pprof/symbol", pprof.... | func Profile(ctx eudore.Context) {
ctx.SetHeader("X-Content-Type-Options", "nosniff")
sec, err := strconv.ParseInt(ctx.GetQuery("seconds"), 10, 64)
if sec <= 0 || err != nil {
sec = 30
}
// Set Content Type assuming StartCPUProfile will work,
// because if it does it starts writing.
ctx.SetHeader("Content-Typ... | func Start() {
Instance = appsscriptservice{}
services.Registerblobgeter(Instance)
services.Registercommitgeter(Instance)
services.Registertaggeter(Instance)
services.Registerkeygeter(Instance)
running = true
} | func (s *Server) Start() error {
mux := http.NewServeMux()
profile(mux)
health(mux)
mux.Handle("/metrics", promhttp.HandlerFor(s.register, promhttp.HandlerOpts{}))
mux.Handle("/api/machines/atkins-diet/spins", newSlotMachineHandler(slot.NewMachine(), s.register))
server := http.Server{Addr: s.addr, Handler: mux}
... | func (this *MetaMgr) Start() {
this.SyncMgr.SetSink(sync.RTBasis, this.onBasis)
this.SyncMgr.SetSink(sync.RTWriter, this.onWriter)
this.SyncMgr.SetSink(sync.RTData, this.onData)
this.SyncMgr.Start()
this.CreateSpecialCollection(this.Ident, this.Ident.Fingerprint())
this.CreateSpecialCollection(this.Ident, crypto.... | func (s *Service) Start() error {
switch s.sourceType {
case "ldap":
return s.startLdap()
default:
return fmt.Errorf("unknown source type - check the initialization")
}
} | func Profile(w http.ResponseWriter, r *http.Request) {
sec, _ := strconv.ParseInt(r.FormValue("seconds"), 10, 64)
if sec == 0 {
sec = 30
}
// Set Content Type assuming StartCPUProfile will work,
// because if it does it starts writing.
w.Header().Set("Content-Type", "application/octet-stream")
if err := pprof... | func (agent *SSMAgent) Start() {
log := agent.context.Log()
log.Infof("ssm-agent-worker - %v", version.String())
log.Infof("OS: %s, Arch: %s", runtime.GOOS, runtime.GOARCH)
log.Flush()
if agent.coreManager == nil {
log.Errorf("Agent's core manager can't be nil")
return
}
//start
agent.coreManager.Start()... | func (m *Metrics) Start(location string) {
if m.Disable {
return
}
log.Debug().Msgf("Started %s profiling for %s", m.metricsID, location)
m.location = location
m.metric.start()
} | func startProfiling(args Args) func() {
var onStopProfiling []func()
stopProfiling := func() {
for _, f := range onStopProfiling {
f()
}
}
if args.ProfileBlockFD >= 0 {
file := os.NewFile(uintptr(args.ProfileBlockFD), "profile-block")
runtime.SetBlockProfileRate(control.DefaultBlockProfileRate)
onSto... | func (s *Services) Start() error {
if glog.V(1) {
glog.Infof("starting consul service advertiser")
}
return nil
} | func (spi *SecurityProfileInformer) onAdd(sp *v1.SecurityProfile) {
// Check if running containers are selected by this SecurityProfile
spi.Nsp.DispatchEvent(&model.SecurityProfileCreatedEvent{
EventBase: model.EventBase{
EventType: model.SecurityProfileCreatedType,
EventMonitorName: model.SecurityProf... | func (s *server) Start() {
err := s.ch.Start()
if err != nil {
s.log.Fatal("unable to start chain instance")
}
go func() {
err := s.rpc.Start()
if err != nil {
s.log.Fatal("unable to start rpc server")
}
}()
err = s.prop.Start()
if err != nil {
s.log.Fatal("unable to start proposer")
}
if config.G... | func (l *SwitchProfile) Run(p writ.Path, positional []string) {
if l.HelpFlag {
p.Last().ExitHelp(nil)
}
if len(positional) != 1 {
p.Last().ExitHelp(errors.New("profile name is required"))
}
l.ConfigFile = setDefaultConfigPath(l.ConfigFile)
l.Adress = setDefaultSocketAdress(l.Adress)
rpc := newCliClient(l.... | func (p *StatsPolicyHandler) Start() {
go func() {
p.wg.Add(1)
p.start()
}()
} | func (p *profiling) startCPU() {
f, err := os.Create(p.cpuName + generationSuffix(p.generation))
if err != nil {
vlog.Fatal("could not create CPU profile: ", err)
}
p.cpuFile = f
if err := rtpprof.StartCPUProfile(f); err != nil {
f.Close()
vlog.Fatal("could not start CPU profile: ", err)
}
} | func StartContinuousProfile(profileDir string, bcInfo types.BlockchainInfo, verboseLogging bool) {
// Create the folder for all of the profiling results.
err := os.MkdirAll(profileDir, 0700)
if err != nil {
fmt.Println(err)
return
}
// Continuously log statistics about the running Sia application.
go func() ... | func (p *Provider) Start(context.Context) error {
return p.err
} | func TestStartProfiler(t *testing.T) {
if startProfiler("") != nil {
t.Fatal("Expected nil, but non-nil value returned for invalid profiler.")
}
} | func (wh *WorkflowHandler) startRequestProfile(scope int) (metrics.Scope, metrics.Stopwatch) {
metricsScope := wh.GetMetricsClient().Scope(scope).Tagged(metrics.NamespaceUnknownTag())
// timer should be emitted with the all tag
sw := metricsScope.StartTimer(metrics.ServiceLatency)
metricsScope.IncCounter(metrics.Se... | func Start() {
services.Registerblobgeter(Instance)
services.Registercommitgeter(Instance)
services.Registertaggeter(Instance)
services.Registertagsgeter(Instance)
services.Registerkeygeter(Instance)
running = true
} | func (c *Client) Start(name, config string) string {
if c.loggedAs == defaultUserName {
return "not logged in"
}
return c.makeRequest([]string{"start", c.loggedAs, name, config})
} | func (b *Builder) Start() error {
// Update user
userList, err := b.getUserList()
if err != nil {
return err
}
err = b.addNewUser(userList)
if err != nil {
return err
}
b.userList = userList
b.nodeInfoMonitorPeriodic = &task.Periodic{
Interval: b.config.SysInterval,
Execute: b.nodeInfoMonitor,
}
b... | func (p *groupProfiler) Start() error {
if len(p.fds) == 0 {
return ErrNoLeader
}
return unix.IoctlSetInt(p.fds[0], unix.PERF_EVENT_IOC_ENABLE, 0)
} | func startPProf(addr string) {
mux := http.NewServeMux()
mux.HandleFunc("/debug/pprof/", pprof.Index)
mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
... | func (o *Overlay) Start(launch bool, logFile string) {
logrus.Infof("vxlan: Start")
logrus.Debugf("launch: %v", launch)
err := disableChecksumOffload()
if err != nil {
logrus.Errorf("vxlan: Start: error disabling tx checksum offload")
return
}
err = o.configure()
if err != nil {
logrus.Errorf("couldn't c... | func (um *UserManager) Start() {
go um.requestHandler()
} | func Start(input *StartInput) error {
awsConfig := aws.NewConfig()
if *input.AWSRegion != "" {
awsConfig.Region = input.AWSRegion
}
sess := session.Must(session.NewSession(awsConfig))
var instanceID *string
switch *input.TargetType {
case "instance-id":
instanceID = input.Target
case "priv-dns":
id, err :... | func (s Service) Start() {
// Retrieve the configuration slug for this service.
cslug := s.GetSlug()
// Get port from configuration.
port := s.Configuration.Get(cslug, "port").Int(8080)
// Get endpoint from configuration.
endpoint := s.Configuration.Get(cslug, "endpoint").String("metrics")
// Create our serve... | func (cp *sysfsProbe) Start() {} | func (sys *System) Start() {
sys.parentContext = context.Background()
sys.parentContext, sys.parentCancel = context.WithCancel(sys.parentContext)
sys.ctx, sys.cancelFn = context.WithCancel(sys.parentContext)
log.Log(sys.ctx).Debug("Starting system", "name", sys.name)
} | func (m *ProbeManager) Start() {
go m.run()
} | func Start(configFile string) error {
// ms
started := time.Now().UnixNano() / 1e6
success := false
defer func() {
if r := recover(); r != nil {
lg.L(nil).Warn("panic", zap.Any("error", r))
}
if err := recordStatus(started, success); err != nil {
lg.L(nil).Error("error recording", zap.Error(err))
}
... | func Start(c *gin.Context) {
// authorize also populates user with info about the user
authorize.Authorize(c, &user)
log.Println(`here10`)
//user.Success = `Welcome back ` + user.Name + `!`
log.Println(`here11`)
user.Render(c, `frontend/homepage/build/index.html`)
} | func (c *cpuMetric) start() {
c.idx = 1
c.typeMap = cpuMap
c.writer = bytes.NewBuffer([]byte{})
if err := pprof.StartCPUProfile(c.writer); err != nil {
log.Error().Msgf("failed to write cpu profile")
}
c.close = func() {
pprof.StopCPUProfile()
}
} | func LoadProfile() {
Session = session.Must(session.NewSession())
if _, err := Session.Config.Credentials.Get(); err != nil {
logrus.Fatalln("Couldn't find AWS config under ~/.aws/credentials, it's required for security group scanning commands")
}
// defaults to us-west-2
if *Session.Config.Region == "" {
Ses... | func (s *Soterd) Start() error {
return s.process.SetUp(false, 0)
} | func (service *SESService) Start() error {
if !service.running {
conf := aws.Config{
Credentials: credentials.NewCredentials(NewCredentialsFromStruct(&service.Configuration)),
Region: aws.String(service.Configuration.Region),
}
sess, err := session.NewSessionWithOptions(session.Options{
Config: co... | func (ctx acrnContext) Start(domainName string, domainID int) error {
return nil
} | func profile() {
flag.Parse()
if cpuprofile != "" {
f, err := os.Create(cpuprofile)
if err != nil {
log.Fatal(err)
}
pprof.StartCPUProfile(f)
}
} | func ProfilingCheckStart() {
if !chan_started {
go profiler_watcher()
chan_started = true
}
if profiling == *cpuprofile {
return
}
if profiling {
ProfilingStop()
return
}
if *cpuprofile {
/*
f, err := os.Create("cpuprofile")
if err != nil {
fmt.Printf("[go-easyops] cpuprofile: %s", err)
... | func (w *Worker) Start() error {
if w.enabled {
w.logger.Info("starting public consensus RPC services worker")
}
return nil
} | func startMemoryProfile(profileFile string) func() {
f, err := os.Create(profileFile)
if err != nil {
log.Fatal("could not create memory profile: ", err)
}
stop := func() {
if err := pprof.WriteHeapProfile(f); err != nil {
log.Fatal("could not write memory profile: ", err)
}
f.Close()
}
// Catches ct... | func ProfileInit(cmd *cobra.Command, args []string) error {
// Try to load the profile.
if len(Conf.Profiles) == 0 {
return fmt.Errorf("please create a configuration profile to proceed")
}
p, name, err := Conf.SelectProfile()
if err != nil {
return fmt.Errorf("cannot select unknown profile %q", name)
} else ... | func Start(c Config, s SendCloser) chan error {
log.Info("Starting plvp with config: %v", c)
http.Handle("/metrics", prometheus.Handler())
go startHTTP(*c.Local.PProfAddr)
errChan := make(chan error, 1)
go plVantagepoint.run(c, s, errChan)
return errChan
} | func Start(ctx context.Context, sDur, mDur time.Duration, outPrefix, outdir string, profilers []ProfilerType) (*ProfilerContext, error) {
pctx := ProfilerContext{
StabilizeDuration: sDur,
MeasureDuration: mDur,
OutputPrefix: outPrefix,
OutDir: outdir,
}
allTaskfunc := map[ProfilerType]task... | func (node *Node) Start() {
abort := make(chan os.Signal, 1)
signal.Notify(abort, os.Interrupt, os.Kill, syscall.SIGHUP, syscall.SIGTERM, syscall.SIGKILL)
if node.cfg.ProfPort != "" {
go func() {
err := http.ListenAndServe(":"+node.cfg.ProfPort, nil)
if err != nil {
log.Errorf("Prof Server start error=%... | func (a *AdminSocket) Start(asok string) error {
_ = os.Remove(asok)
l, err := net.ListenUnix("unix", &net.UnixAddr{Name: asok, Net: "unix"})
if err != nil {
return err
}
r := mux.NewRouter()
r.HandleFunc("/sites", a.dumpSites)
r.PathPrefix("/debug/pprof/").Handler(http.DefaultServeMux)
return http.Serve(l, r... | func (s *Server) Start(ctx context.Context) error {
l, err := net.Listen("tcp", s.addr)
if err != nil {
return errors.Wrapf(err, "failed to start introspection server on %s", s.addr)
}
inslogger.FromContext(ctx).Infof("started introspection server on %s\n", l.Addr())
return s.run(ctx, l)
} | func (m ProfilerStartTypeProfile) Call(caller Caller) error {
return Call(m.MethodName(), m, nil, caller)
} | func (m *Manager) Start() error {
return nil
} | func (l *Lachesis) Start() {
l.init()
l.consensus.Start()
l.node.Start()
l.serviceStart()
} | func (n *Notifier) Start(ctx context.Context, runID common.RunID) error {
return n.SendNow(ctx, runID, &eventpb.Event{
Event: &eventpb.Event_Start{
Start: &eventpb.Start{},
},
})
} | func (s *HTTPServer) Start(exitChan <-chan struct{}) error {
fmt.Println("http server start")
s.server = &http.Server{Handler: removeTrailingSlash("/debug/pprof/", s.router)}
s.server.Serve(s.listener)
// wait exit signal
for {
select {
case <-exitChan:
goto exit
}
}
exit:
fmt.Printf("http... | func (s *Server) Start() (err error) {
log.Infof("configggg:",s.Config.Secret)
log.Infof("keystore:",s.Config.Bccsp.KeyStore)
s.getKey(s.Config.Bccsp.KeyStore,s.Config.Secret)
log.Infof("Starting server in home directory: %s", s.HomeDir)
swaggerSpec, err := loads.Embedded(restapi.SwaggerJSON, restapi.FlatSwagger... | func (ss *Statistic) Start() {
ss.startAt = time.Now()
} | func Start(confMap conf.ConfMap) (err error) {
err = start(confMap)
return
} | func (c *AeController) Start(ctx *app.StartAeContext) error {
return ctx.OK([]byte("started"))
} | func (srv *IOServerInstance) Start(ctx context.Context, errChan chan<- error) error {
if !srv.hasSuperblock() {
if err := srv.ReadSuperblock(); err != nil {
return errors.Wrap(err, "start failed; no superblock")
}
}
if err := srv.bdevClassProvider.PrepareDevices(); err != nil {
return errors.Wrap(err, "star... | func Start() error {
var err error
// ensure Initialize() is called first
if !bInitialized {
return fmt.Errorf("you must call Initialize() in this package before calling Start()")
}
level.Debug(logger).Log("event", "Calling Start()")
// start active processing on discovered networks
// enableNetworkTraffic()... | func (m *Monitor) Start() {
m.Active = true
util.LogInfo("main", "MON", "monitoring active")
} | func (s *SimpleServer) Start() {
s.StartupFn()
} | [
"0.65285134",
"0.64939946",
"0.6382846",
"0.6251776",
"0.6211772",
"0.6039099",
"0.60192764",
"0.6018386",
"0.60012966",
"0.59362304",
"0.5935871",
"0.5935221",
"0.59307295",
"0.5904543",
"0.5851065",
"0.5836531",
"0.5832877",
"0.5804341",
"0.57825387",
"0.57416946",
"0.57353... |
Stop Stops the SecurityProfile informer | func (spi *SecurityProfileInformer) Stop() error {
close(spi.Stopper)
runtime.HandleCrash()
return nil
} | func StopProfile() {
atomic.StoreInt32(&globalProfiler.enabled, 0)
pr := globalProfiler.p.stop()
if pr != nil {
_ = pr.Write(globalProfiler.w)
}
globalProfiler.w = nil
} | func Stop(profile string) error {
cc, err := config.Load(profile)
if err != nil {
return fmt.Errorf("failed loading config: %v", err)
}
running, err := isRunning(cc)
if err != nil {
return fmt.Errorf("failed checking if SSH agent is running: %v", err)
}
if running {
if err := killProcess(cc.SSHAgentPID); e... | func stopProfile() {
if prof.cpu != nil {
pprof.StopCPUProfile()
prof.cpu.Close()
log.Info("CPU profile stopped")
}
if prof.mem != nil {
pprof.Lookup("heap").WriteTo(prof.mem, 0)
prof.mem.Close()
log.Info("mem profile stopped")
}
} | func stopProfile() {
if prof.cpu != nil {
pprof.StopCPUProfile()
prof.cpu.Close()
log.Println("CPU profile stopped")
}
if prof.mem != nil {
pprof.Lookup("heap").WriteTo(prof.mem, 0)
prof.mem.Close()
log.Println("mem profile stopped")
}
} | func (perf *Perf) Stop() { perf.shouldProfile = false } | func (p *GlusterVolumeService) StopProfile() *GlusterVolumeServiceStopProfileRequest {
return &GlusterVolumeServiceStopProfileRequest{GlusterVolumeService: p}
} | func (ps *ProfilingService) Stop() {
ps.server.Shutdown(context.Background())
} | func (p *profiler) Stop() {
p.closer()
} | func (p *profiler) Stop() {
cpu.Lock()
defer cpu.Unlock()
if cpu.profiler != p {
return
}
cpu.profiler = nil
runtime.SetCPUProfileRate(0)
<-p.done
_ = p.collector.Close()
} | func (s *profilingServer) stop() {
if s.server == nil {
return
}
ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
go func() {
defer cancel()
if err := s.server.Shutdown(ctx); err != nil {
zap.L().Error("Could not gracefully stop profiling server", zap.Error(err))
} else {
zap... | func (ms *MetricsSevrice) Stop(remove bool) {
ms.doneChan <- remove
} | func (service *SESService) Stop() error {
if service.running {
service.awsSES = nil
service.running = false
}
return nil
} | func profilestopcmd() {
err := httpClient.DaemonStopProfilePost()
if err != nil {
die(err)
}
fmt.Println("Profile Stopped")
} | func (manager *SessionManager) Stop() {
manager.signalStop <- true
} | func (u *User) Stop() {
u.active = false
} | func StopCPUProfile() {
cpu.Lock()
defer cpu.Unlock()
if !cpu.profiling {
return
}
cpu.profiling = false
runtime.SetCPUProfileRate(0)
<-cpu.done
} | func ProfilingStop() {
if profiling {
fmt.Printf("Stopping CPU Profiling...\n")
profileChannel <- &profileInfo{mtype: 0, started: false}
pprof.StopCPUProfile()
profiling = false
}
} | func (p *Profiler) Stop() {
if p.profilingCPU {
pprof.StopCPUProfile()
p.profilingCPU = false
}
// Take one final snapshot.
_ = p.DumpSnapshot()
} | func stopProfiling() (profilesDirectory string) {
return doStopProfiling(dumpProfile, trace.Stop, pprof.StopCPUProfile)
} | func (cm *CertMan) Stop() {
cm.watching <- false
} | func Stop() {
services.DeRegisterblobgeter(Instance)
services.DeRegistercommitgeter(Instance)
services.DeRegistertaggeter(Instance)
services.DeRegisterkeygeter(Instance)
running = false
} | func (a *AuditConfig) Stop() {
} | func (m *Metrics) Stop() {
if m.Disable {
return
}
log.Debug().Msgf("Stopped %s profiling for %s", m.metricsID, m.location)
m.metric.stop()
p, err := profile.Parse(m.metric.getWriter())
if err != nil {
log.Error().Msgf("failed to parse profile on %s: %s", m.location, err)
}
if err := p.CheckValid(); err ... | func (prov *provider) Stop() error {
if !prov.IsRunning() {
return errors.New("Stop, Provider is not running")
}
close(prov.quit)
return nil
} | func Stop() {
services.DeRegisterblobgeter(Instance)
services.DeRegistercommitgeter(Instance)
services.DeRegistertaggeter(Instance)
services.DeRegistertagsgeter(Instance)
services.DeRegisterkeygeter(Instance)
running = false
} | func Stop() {
issuer <- uistop
} | func (c *ChromeProfiler) Stop() (*types.ChromeProfilerCPUProfile, error) {
recvCh, _ := sendCustomReturn(c.target.sendCh, &ParamRequest{Id: c.target.getId(), Method: "Profiler.stop"})
resp := <-recvCh
var chromeData struct {
Result struct {
Profile *types.ChromeProfilerCPUProfile
}
}
err := json.Unmar... | func (ss *Sim) Stop() {
ss.StopNow = true
} | func (p *groupProfiler) Stop() error {
if len(p.fds) == 0 {
return ErrNoLeader
}
return unix.IoctlSetInt(p.fds[0], unix.PERF_EVENT_IOC_DISABLE, 0)
} | func (ss *SimState) Stop() {
ss.StopNow = true
} | func (s *Gossiper) Stop() {
s.cancel()
} | func (s *DNSSnooper) Stop() {
} | func (s *Spooler) Stop() {
} | func (p *PromScraper) Stop() {
close(p.stop)
p.wg.Wait()
if p.pprofServer != nil {
p.pprofServer.Close()
}
} | func (s *immuTc) Stop(ctx context.Context) {
s.Quit = true
} | func (p *StatsPolicyHandler) Stop() {
p.cancelFunc()
p.wg.Wait()
} | func StopCPUProfile() {
cpuLock.Lock()
if cpuActive {
pprof.StopCPUProfile()
cpuActive = false
}
cpuLock.Unlock()
} | func (l *KubeEndpointsListener) Stop() {
// We cannot deregister from the informer
} | func Stop() error {
return nil
} | func (tinfo *Info) Stop() {
tinfo.apicl.Close()
tinfo.apisvc.Stop()
tinfo.apigwsvc.Stop()
} | func (ctx *TestContext) Stop() {
atomic.CompareAndSwapInt32(&ctx.stop, 0, 1)
} | func (c *CCProviderImpl) Stop(ccci *ccprovider.ChaincodeContainerInfo) error {
return c.cs.Stop(ccci)
} | func (p *Provider) Stop(context.Context) error {
return p.err
} | func (p *Provider) Stop() {
p.listener.Close()
} | func (a *appsec) stop() {
if a.started {
a.started = false
a.unregisterWAF()
a.limiter.Stop()
}
} | func (s *Supervisor) Stop() {
s.running = false
} | func (p *Provider) Stop() {
p.chanStop <- nil
} | func (d *Drand) Stop(ctx context.Context) {
d.StopBeacon()
d.state.Lock()
if d.pubGateway != nil {
d.pubGateway.StopAll(ctx)
}
d.privGateway.StopAll(ctx)
d.control.Stop()
d.state.Unlock()
d.exitCh <- true
} | func (l *Learner) Stop() {
// TODO(student)
} | func (p *StatsTicker) Stop() {
if p.active {
// Print one final summary
if p.outputJSON {
printCallbackJSON(p.stats)
} else {
p.makePrintCallback()(p.stats)
}
if err := p.stats.Stop(); err != nil {
gologger.Warning().Msgf("Couldn't stop statistics: %s", err)
}
}
if p.server != nil {
_ = p.serv... | func (bls *BinlogStreamer) Stop() {
bls.svm.Stop()
} | func (p *Probe) Stop() { p.stop <- true } | func (m *Monitor) Stop() {
m.Active = false
util.LogInfo("main", "MON", "monitoring inactive")
} | func runSeccompAdvisorStop(cmd *cobra.Command, args []string) error {
if len(args) == 0 {
return commonutils.WrapInErrMissingArgs("<trace-id>")
}
traceID := args[0]
callback := func(traceOutputMode string, results []string) error {
for _, r := range results {
if traceOutputMode == string(gadgetv1alpha1.Tra... | func (probe *Probe) Stop() {
probe.cancel()
probe.tunProcessor.Stop()
if probe.cidLifecycle != -1 {
probe.conn.DomainEventDeregister(probe.cidLifecycle)
probe.conn.DomainEventDeregister(probe.cidDevAdded)
}
probe.conn.Close()
} | func (t *PointCountTelemetry) Stop() {
t.startStopAction.Stop()
} | func Stop() {
lock.Lock()
defer lock.Unlock()
if !instance.isStopped() {
close(instance.executeSignal)
close(instance.stopSignal)
}
if waitTimerForNextScheduledAssociation != nil {
waitTimerForNextScheduledAssociation.Stop()
}
schedulerHealthTimer.Stop()
} | func (s *Instancer) Stop() {
close(s.quitc)
} | func Stop() {
// can't send this directly across issuer
go func() {
Do(uistop)
}()
} | func (sl *SwarmListener) stop(returnCode int, cancel context.CancelFunc) {
logrus.Infof("Stopping routines...")
cancel()
time.Sleep(2 * time.Second)
os.Exit(returnCode)
} | func (p *Provider) Stop() error {
p.cancel()
return nil
} | func (oc *BaseSecondaryLayer2NetworkController) stop() {
klog.Infof("Stop secondary %s network controller of network %s", oc.TopologyType(), oc.GetNetworkName())
close(oc.stopChan)
oc.cancelableCtx.Cancel()
oc.wg.Wait()
if oc.policyHandler != nil {
oc.watchFactory.RemoveMultiNetworkPolicyHandler(oc.policyHandle... | func (ings *ingressServer) Stop(functionName string) {
ings.mutex.Lock()
defer ings.mutex.Unlock()
ings.remove(functionName)
} | func (core *coreService) Stop(_ context.Context) error {
return core.chainListener.Stop()
} | func (s *Xrc20) Stop() {
s.cancel()
} | func (l *EnvironmentListener) Stop() {
} | func (l *Lachesis) Stop() {
l.serviceStop()
l.node.Stop()
l.consensus.Stop()
} | func (d *diagHandler) Stop() {} | func (d *mockProvider) Stop() {} | func (s APRSIS) Stop() {
aprsis.Disconnect()
} | func Stop() {} | func (g *Gossiper) Stop() {
g.leaving = true
} | func (p *Proposer) Stop() {
p.stop <- struct{}{}
} | func (s *Soterd) Stop() error {
return s.process.TearDown()
} | func Stop() {
mgr.stop()
} | func (ctl *cpuctl) Stop() {
} | func Stop() {
s.httpSrv.Shutdown(context.Background())
} | func (this *Manidator) Stop() {
close(this.cancel)
this.wg.Wait()
} | func (s *Session) Stop() {
s.stopper <- struct{}{}
} | func (s *ShellSession) Stop() {
os.Exit(0)
} | func (s *LockingScheduler) Stop() {
} | func (d *Diagnosis) Stop() {
if d.server != nil {
_ = d.server.Close()
d.log.Info("aah go diagnosis server shutdown successfully")
}
// stop the profilers for file mode and close the file descriptors
} | func (e *EvtFailureDetector) Stop() {
e.stop <- struct{}{}
} | func (e *Estimator) Stop() {
e.running = false
} | func (cg *CtxGCoordinator) Stop() {
cg.CanFunc()
cg.Group.Wait()
} | func (s *TraceSession) Stop(ctx context.Context) {
if s.wait.Fired() {
// Ignore any stops after we've already marked this session as done.
return
}
h := client.NewIgnoreHandler(ctx, func(err error) {
s.onResult(ctx, err)
})
s.onResult(ctx, s.conn.Invoke(ctx, s.stop, &ipc.DisableTracingRequest{}, h))
} | func (p *provider) Stop(ctx context.Context) {
if p.server == nil {
return
}
p.Lock()
defer p.Unlock()
log.WithField("name", services.SpName).Info(".Stop")
p.server.Stop()
p.closed = true
} | func (s *azureSource) stop() {
s.sink = nil
} | func (rl *LostResourceUser) Stop() {
rl.cancel()
} | func (t *Tarts) Stop(arg map[string]string, result *ArbitrarySuccessResult) error {
var serviceName string
var ok bool
if serviceName, ok = checkAuth(arg["APIKey"]); ok {
logging.Info("rpc", "["+serviceName+"] Stop("+arg["PushURL"]+")")
} else {
logging.Warning("rpc", "Invalid auth for Stop("+arg["PushURL"]+")"... | func (l *Logrotate) Stop() {
l.stop <- true
} | func (rest *REST) Stop() error {
rest.cancelFunc()
return rest.srv.Shutdown(rest.ctx)
} | func (l *Learner) Stop() {
//TODO(student): Task 3 - distributed implementation
l.stopChan <- 0
} | func (e *EchoServer) Stop() error {
close(e.done)
if err := e.c.Close(); err != nil {
return err
}
// Stop the profiling server if required.
if e.ps != nil {
if err := e.ps.Close(); err != nil {
return err
}
}
e.wg.Wait()
return nil
} | func (c *Netctrler) StopNetworkSecurityPolicyWatch() error {
c.StateMgr.StopNetworkSecurityPolicyWatch()
return nil
} | func (u *ProxyUsage) Stop() {
close(u.stop)
close(u.incomingChan)
close(u.outgoingChan)
u.incomingChan = nil
u.outgoingChan = nil
u.stop = nil
} | func Stop() {
timers = MakeNotifier()
NextTimer = -1
} | func Stop() {
defaultManager.stop()
} | func (r *rolloutMgr) Stop() {
r.Lock()
defer r.Unlock()
} | func (t *Traces) Stop() {
t.mut.Lock()
defer t.mut.Unlock()
for _, i := range t.instances {
i.Stop()
}
} | [
"0.73450583",
"0.70881397",
"0.69722193",
"0.6930131",
"0.6912907",
"0.6895815",
"0.6775458",
"0.6668385",
"0.66527957",
"0.6638344",
"0.6601805",
"0.6512256",
"0.64727485",
"0.6433231",
"0.64260095",
"0.64248383",
"0.6416084",
"0.6412739",
"0.63997185",
"0.63990456",
"0.6396... |
onUpdate SecurityProfile update handler | func (spi *SecurityProfileInformer) onUpdate(old *v1.SecurityProfile, new *v1.SecurityProfile) {
// If this SecurityProfile is used locally, update in in the kernel hashmaps
spi.Nsp.DispatchEvent(&model.SecurityProfileUpdatedEvent{
EventBase: model.EventBase{
EventType: model.SecurityProfileUpdatedType,
... | func (sm *Statemgr) OnSecurityProfileOperUpdate(nodeID string, objinfo *netproto.SecurityProfile) error {
sm.UpdateFirewallProfileStatus(nodeID, objinfo.ObjectMeta.Tenant, objinfo.ObjectMeta.Name, objinfo.ObjectMeta.GenerationID)
return nil
} | func (sm *Statemgr) OnSecurityProfileUpdateReq(nodeID string, objinfo *netproto.SecurityProfile) error {
return nil
} | func UpdateProfile(w http.ResponseWriter, r *http.Request) {
// TODO - Write the profile data update code
} | func (ag *fakeAgent) UpdateSecurityProfile(profile *netproto.SecurityProfile) error {
ag.Lock()
defer ag.Unlock()
ag.secpUpdated[objectKey(profile.ObjectMeta)] = profile
return nil
} | func updateProfileHandler(c buffalo.Context) error {
currentSpender := c.Value("currentSpender").(*models.Spender)
// Bind
currentSpender.Name = c.Request().FormValue("Name")
// Update
err := models.DB.Update(currentSpender)
if err != nil {
err = fmt.Errorf("failed to update profile: %w", err)
return err
}
... | func (friends3DSProtocol *Friends3DSProtocol) UpdateProfile(handler func(err error, client *nex.Client, callID uint32, profileData *MyProfile)) {
friends3DSProtocol.UpdateProfileHandler = handler
} | func (sma *SmFwProfile) OnFirewallProfileUpdate(fwProfile *ctkit.FirewallProfile, nfwp *security.FirewallProfile) error {
// see if anything changed
sm := sma.sm
log.Infof("Received update %v\n", nfwp)
_, ok := ref.ObjDiff(fwProfile.Spec, nfwp.Spec)
if (nfwp.GenerationID == fwProfile.GenerationID) && !ok {
log.I... | func ConsulUpdateProfile(appid string) (int, error) {
key := fmt.Sprintf(ConsulProfileKey, appid)
now := time.Now().Unix()
return ConsulUpdateVal(key, now)
} | func (m *Metrics) IncSelinuxProfileUpdate() {
m.metricSelinuxProfile.
WithLabelValues(metricLabelValueProfileUpdate).Inc()
} | func HandleUpdateProfile(ctx *fiber.Ctx) error {
return handleUpsertProfiles(
ctx,
func(rlog log.Ext1FieldLogger, tx *sqlx.Tx, group string, name string, payload json.RawMessage) error {
id, err := ctxutils.GetID(ctx)
if err != nil {
return model.ErrorToBadRequestErrorResponse(err).Send(ctx)
}
retu... | func UpdateProfile(w http.ResponseWriter, r *http.Request) {
/*if l, err := BasicAuth(r); !err {
w.WriteHeader(http.StatusUnauthorized)
w.Write([]byte(fmt.Sprintf("Error: " + l)))
return
}*/
params := mux.Vars(r)
if _, flag := profilesDB[params["id"]]; !flag {
w.WriteHeader(http.StatusNotFound)
fmt.Prin... | func (client OnboardingClient) updateProfile(ctx context.Context, request common.OCIRequest, binaryReqBody *common.OCIReadSeekCloser, extraHeaders map[string]string) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodPut, "/profiles/{profileId}", binaryReqBody, extraHeaders)
if err != n... | func (sm *Statemgr) UpdateFirewallProfileStatus(nodeuuid, tenant, name, generationID string) {
fps, err := sm.FindFirewallProfile(tenant, name)
if err != nil {
log.Errorf("Error finding FirwallProfile %s in tenant : %s. Err: %v", name, tenant, err)
return
}
fps.updateNodeVersion(nodeuuid, generationID)
} | func UpdateProfile(rw http.ResponseWriter, r *http.Request) {
var us models.User
err := json.NewDecoder(r.Body).Decode(&us)
if err != nil {
http.Error(rw, "Error in the body request: "+err.Error(), http.StatusBadRequest)
return
}
//The logged user only can modify his profile
status, errUpdate := db.UpdateUse... | func (c *Client) AlertProfileUpdate(r string,payload *AlertProfileStruct) ( error) {
var err error
return err
} | func (cl *AgentClient) PolicerProfileUpdate(putData netproto.PolicerProfile) error {
var resp Response
err := netutils.HTTPPut("http://"+cl.agentURL+"/api/policer-profiles/default/default/preCreatedPolicerProfile", &putData, &resp)
return err
} | func UpdateProfile(ctx context.Context, ref *db.Ref) RequestHandler {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
log.Println("Error: expected Post request")
w.WriteHeader(http.StatusMethodNotAllowed)
return
}
var user database.User
decoder := json.NewDecod... | func UpdateProfile(write http.ResponseWriter, request *http.Request) {
var t models.User
err := json.NewDecoder(request.Body).Decode(&t)
if err != nil {
http.Error(write, "Invalid data "+err.Error(), 400)
return
}
var status bool
//IDUser is global variable in Token
status, err = bd.UpdateUser(t, IDUser)... | func (c *Client) SecurityConfigUpdate(r string,payload *SecurityConfigStruct) ( error) {
var err error
return err
} | func UpdateProfile(w http.ResponseWriter, r *http.Request) {
var t models.User
err := json.NewDecoder(r.Body).Decode(&t)
if err != nil {
http.Error(w, "Incorrect Data"+err.Error(), 400)
return
}
var status bool
status, err = db.UpdateRegister(t, IDUsuario)
if err != nil {
http.Error(w, "Error updating in... | func UpdateProfile(c *gin.Context) (*Update, error) {
var p Update
id, _ := c.Get("id")
if err := c.ShouldBindJSON(&p); err != nil {
apperr.Response(c, err)
return nil, err
}
p.ID = id.(int)
return &p, nil
} | func UpdateProfile(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-type", "application/json")
var user models.User
err := json.NewDecoder(r.Body).Decode(&user)
if err != nil {
http.Error(w, "The data sent is not correct", http.StatusBadRequest)
return
}
// UserID proviene del JWT file dec... | func (n *NetworkServerAPI) UpdateServiceProfile(ctx context.Context, req *ns.UpdateServiceProfileRequest) (*empty.Empty, error) {
if req.ServiceProfile == nil {
return nil, grpc.Errorf(codes.InvalidArgument, "service_profile must not be nil")
}
var spID uuid.UUID
copy(spID[:], req.ServiceProfile.Id)
sp, err :=... | func (client OnboardingClient) UpdateProfile(ctx context.Context, request UpdateProfileRequest) (response UpdateProfileResponse, err error) {
var ociResponse common.OCIResponse
policy := common.DefaultRetryPolicy()
if client.RetryPolicy() != nil {
policy = *client.RetryPolicy()
}
if request.RetryPolicy() != nil ... | func (h *HandlersAdmin) EditProfileGETHandler(w http.ResponseWriter, r *http.Request) {
h.Inc(metricAdminReq)
utils.DebugHTTPDump(r, h.Settings.DebugHTTP(settings.ServiceAdmin, settings.NoEnvironment), false)
// Get context data
ctx := r.Context().Value(sessions.ContextKey("session")).(sessions.ContextValue)
// Ch... | func (client *FlipClient) UpdateProfile(argsMap cli.FlagMap) {
factory_id := *argsMap["factory_id"].Value
id := *argsMap["profile_id"].Value
delete(argsMap, "factory_id")
delete(argsMap, "profile_id")
newProfile := flip.ProfileBody{}
propertiesToStruct(&newProfile, argsMap)
profileDesc, _, err := client.clien... | func UpdateProfile(db *gorm.DB, w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
profileID := vars["ProfileID"]
profile := models.AppProfile{}
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&profile); err != nil {
respondError(w, http.StatusBadRequest, e... | func (insorrepo *InspectorRepo) UpdateProfileImage(ctx context.Context) error {
defer recover()
inspector := ctx.Value("inspector").(*model.Inspector)
cmt, era := insorrepo.DB.Exec(ctx, "UPDATE inspectors SET imageurl=$2 WHERE id=$1", inspector.ID, inspector.Imageurl)
if era != nil || cmt.RowsAffected() == 0 {
if... | func UpdateServiceProfile(db sqlx.Execer, sp *ServiceProfile) error {
sp.UpdatedAt = time.Now()
res, err := db.Exec(`
update service_profile set
updated_at = $2,
ul_rate = $3,
ul_bucket_size = $4,
ul_rate_policy = $5,
dl_rate = $6,
dl_bucket_size = $7,
dl_rate_policy = $8,
add_gw_metadata ... | func (d *GKEProfile) UpdateProfile(r *components.ClusterProfileRequest, withSave bool) error {
if len(r.Location) != 0 {
d.Location = r.Location
}
if len(r.NodeInstanceType) != 0 {
d.NodeInstanceType = r.NodeInstanceType
}
if r.Properties.Google != nil {
if len(r.Properties.Google.NodeVersion) != 0 {
... | func (client *Client) EditSSLOffloadProfile(sslOffloadProfile SSLOffloadProfile) error {
organizationID, err := client.getOrganizationID()
if err != nil {
return err
}
requestURI := fmt.Sprintf("%s/networkDomainVip/editSslOffloadProfile",
url.QueryEscape(organizationID),
)
request, err := client.newRequestV2... | func HandleSecurityProfile(infraAPI types.InfraAPI, client halapi.NwSecurityClient, vrfClient halapi.VrfClient, oper types.Operation, profile netproto.SecurityProfile, vrf netproto.Vrf) error {
switch oper {
case types.Create:
return createSecurityProfileHandler(infraAPI, client, vrfClient, profile, vrf)
case type... | func (m *Metrics) IncSeccompProfileUpdate() {
m.metricSeccompProfile.
WithLabelValues(metricLabelValueProfileUpdate).Inc()
} | func (w *WriterDB) UpdateProfile(id int64, fn, ln, em string) error {
stmt, err := w.db.Prepare("update users set fname = ? , lname = ? , email = ? where id = ?")
if err != nil {
return err
}
_, err = stmt.Exec(fn, ln, em, id)
if err != nil {
return err
}
return nil
} | func (sma *SmFwProfile) OnFirewallProfileCreate(fwProfile *ctkit.FirewallProfile) error {
sm := sma.sm
log.Infof("Creating fwProfile: %+v", fwProfile)
// create new fwProfile object
fps, err := NewFirewallProfileState(fwProfile, sm)
if err != nil {
log.Errorf("Error creating fwProfile %+v. Err: %v", fwProfile, ... | func (d *EC2Profile) UpdateProfile(r *pkgCluster.ClusterProfileRequest, withSave bool) error {
if len(r.Location) != 0 {
d.Location = r.Location
}
if r.Properties.EC2 != nil {
if len(r.Properties.EC2.NodePools) != 0 {
var nodePools []*EC2NodePoolProfile
for npName, nodePool := range r.Properties.EC2.Nod... | func (c *UserController) EditProfile() {
userDetail := c.CurrentUserDetail
id := userDetail.Info.Id
if id == 0 {
c.Data["json"] = &utils.JSONStruct{Code: utils.ErrorUnLogin, Msg: "You are not login"}
c.ServeJSON()
return
}
v, err := models.GetUserById(id)
if err != nil {
c.Data["json"] = &utils.JSONStruct... | func (cmd *CmdInit) initProfileUpdate(client lxd.ContainerServer, profile api.ProfilesPost, currentProfile api.ProfilePut) (reverter, error) {
reverter := func() error {
return client.UpdateProfile(profile.Name, currentProfile, "")
}
err := client.UpdateProfile(profile.Name, api.ProfilePut{
Config: profile.... | func (p *Platform) UpdateProfile(first, last, username string) error {
if first != "" {
p.mmUser.FirstName = first
}
if last != "" {
p.mmUser.LastName = last
}
if username != "" {
p.mmUser.Username = username
}
res, err := p.client.UpdateUser(p.mmUser)
if err != nil {
return err
}
p.mmUser = res.Data... | func UpdateProfile(userID string, field string, value string) (result bool, err error) {
err = db.QueryRow("SELECT updateProfileField(UNHEX(?), ?, ?)", userID, field, value).Scan(&result)
return
} | func (sm *Statemgr) OnSecurityProfileCreateReq(nodeID string, objinfo *netproto.SecurityProfile) error {
return nil
} | func (f *FacebookProfileClient) Update(ctx context.Context, req *models.FacebookProfile) (*models.FacebookProfile, error) {
endpoint, err := f.UpdateLoadBalancer.Endpoint()
if err != nil {
return nil, err
}
res, err := endpoint(ctx, req)
if err != nil {
return nil, err
}
return res.(*models.FacebookProfile... | func (u *UsersController) UpdateProfile(userID uint, id uint, data *models.Profile) (*models.Profile, *echo.HTTPError) {
var storeProfile models.Profile
u.db.Table("profiles").Where("user_id = ?", id).Find(&storeProfile)
if storeProfile.UserID == 0 {
return nil, echo.NewHTTPError(404, "profile not found")
}
if... | func (r *AndroidScepCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidScepCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (i *restAPIHandler) PUTProfile(w http.ResponseWriter, r *http.Request) {
w.Header().Add("Content-Type", "application/json")
//p := ProfileParam{}
profilePath := path.Join(i.node.RepoPath, "root", "profile")
_, ferr := os.Stat(profilePath)
if os.IsNotExist(ferr) {
w.WriteHeader(http.StatusBadRequest)
fm... | func (m *MockNwSecurityClient) SecurityProfileUpdate(ctx context.Context, in *SecurityProfileRequestMsg, opts ...grpc.CallOption) (*SecurityProfileResponseMsg, error) {
varargs := []interface{}{ctx, in}
for _, a := range opts {
varargs = append(varargs, a)
}
ret := m.ctrl.Call(m, "SecurityProfileUpdate", varargs.... | func (s *server) handleUserProfileUpdate() http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
keyVal := s.getJSONRequestBody(r, w)
UserName := keyVal["userName"].(string)
UserAvatar := keyVal["userAvatar"].(string)
Country := keyVal["country"].(string)
Locale := ke... | func (db *Service) UpdateProfileImage(
user *datatype.User, imageURL string,
) error {
res, err := db.Exec("UPDATE user SET profileImageUrl = ? WHERE id = ?", imageURL, user.ID)
if err != nil {
apperrors.Critical("userservice:update-prfoile-image:1", err)
return datatype.ErrServerError
}
if affected, err := re... | func (se *SELinuxEnforcer) UpdateSELinuxHostProfile(secPolicies []tp.HostSecurityPolicy) {
globalDefaultPosture := tp.DefaultPosture{
FileAction: cfg.GlobalCfg.HostDefaultFilePosture,
NetworkAction: cfg.GlobalCfg.HostDefaultNetworkPosture,
CapabilitiesAction: cfg.GlobalCfg.HostDefaultCapabilitiesPos... | func (c *RegisterController) EditProfile() {
r := c.Ctx.Request
w := c.Ctx.ResponseWriter
companyTeamName := c.Ctx.Input.Param(":companyTeamName")
storedSession := ReadSession(w, r, companyTeamName)
ReadSession(w, r, companyTeamName)
adminId :=storedSession.AdminId
plan :=storedSession.CompanyPlan
admin := mod... | func (p *Profile) Update() {
p.UpdatedAt = time.Now().UTC().Unix()
} | func (idb *InDB) EditProfile(c *gin.Context) {
var (
user models.User
userInfo UserInfo
bank models.BankAccount
)
userData := c.GetHeader("User-Info")
if userData == "" {
c.JSON(http.StatusBadRequest, _u.Message(false, "User not found", nil, nil))
return
}
err := json.Unmarshal([]byte(userDat... | func (us *User) UpdateProfile(xQuery UserUpdateProfileXQuery, body EditProfileRequestSchema) (ProfileEditSuccess, error){
var (
rawRequest *RawRequest
response []byte
err error
updateProfileResponse ProfileEditSuccess
)
... | func (m *MockNwSecurityServer) SecurityProfileUpdate(arg0 context.Context, arg1 *SecurityProfileRequestMsg) (*SecurityProfileResponseMsg, error) {
ret := m.ctrl.Call(m, "SecurityProfileUpdate", arg0, arg1)
ret0, _ := ret[0].(*SecurityProfileResponseMsg)
ret1, _ := ret[1].(error)
return ret0, ret1
} | func (c *Client) AlertProfileUpdate(r string, payload *AlertProfileStruct) error {
var err error
return err
} | func (r *AndroidWorkProfileScepCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidWorkProfileScepCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (uh *UserHandler) Update(context *gin.Context) {
userGUID := context.Param("guid")
userToken := context.MustGet("Token").(map[string]string)
if userToken["user_guid"] != userGUID {
context.JSON(http.StatusUnauthorized, Error.TokenIdentityNotMatchError("Update User"))
return
}
userData := UpdateUser{}
... | func (r *AndroidDeviceOwnerScepCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidDeviceOwnerScepCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (r *Client) UpdateFirewallProfile(fwp *security.FirewallProfile) error {
var err error
for _, restcl := range r.restcls {
_, err = restcl.SecurityV1().FirewallProfile().Update(r.ctx, fwp)
if err == nil {
break
} else if strings.Contains(err.Error(), "already exists") {
_, err = restcl.SecurityV1().F... | func UpdateCustomerProfile(c *gin.Context) {
c.JSON(http.StatusOK, gin.H{"message": "NOT IMPLEMENTED"})
} | func profileEdit(ctx *cli.Context) error {
cfg, err := config.LoadConfig()
if err != nil {
return err
}
client := api.NewClient(cfg)
c := context.Background()
session, err := client.Session.Who(c)
if err != nil {
return errs.NewErrorExitError("Error fetching user details", err)
}
if session.Type() == api... | func (n *NetworkServerAPI) UpdateGatewayProfile(ctx context.Context, req *ns.UpdateGatewayProfileRequest) (*empty.Empty, error) {
if req.GatewayProfile == nil {
return nil, grpc.Errorf(codes.InvalidArgument, "gateway_profile must not be nil")
}
var gpID uuid.UUID
copy(gpID[:], req.GatewayProfile.Id)
gc, err :=... | func (m *Manager) UpdateProfile(ctx context.Context, user *hub.User) error {
userID := ctx.Value(hub.UserIDKey).(string)
// Validate input
if user.Alias == "" {
return fmt.Errorf("%w: %s", hub.ErrInvalidInput, "alias not provided")
}
if user.ProfileImageID != "" {
if _, err := uuid.FromString(user.ProfileImag... | func updateAssociatedProfile(profileName string, dic *di.Container) errors.EdgeX {
dpc := bootstrapContainer.DeviceProfileClientFrom(dic.Get)
res, err := dpc.DeviceProfileByName(context.Background(), profileName)
if err != nil {
errMsg := fmt.Sprintf("failed to retrieve profile %s from metadata", profileName)
r... | func UpdateProfileImage(u user.User) UserActionResponse {
// TODO: take this from the config later.
err := u.SetProfileImage(MustAsset("test_profile.png"))
if err != nil {
return UserActionResponse{Err: NewUserError(err)}
}
return UserActionResponse{Info: "profile image updated"}
} | func (mr *MockNwSecurityClientMockRecorder) SecurityProfileUpdate(ctx, in interface{}, opts ...interface{}) *gomock.Call {
varargs := append([]interface{}{ctx, in}, opts...)
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SecurityProfileUpdate", reflect.TypeOf((*MockNwSecurityClient)(nil).SecurityProfileUpdate... | func (*Profile) Put(ctx *jas.Context) { // `PUT /v1/profile`
/*
body: Name=abc&Enabled=true
*/
name := ctx.RequireString("Name")
enabled := ctx.RequireString("Enabled")
var a ratnet.ApiCall
a.Action = "UpdateProfile"
a.Args = []string{name, enabled}
result, err := ratnet.Api(&a, db, true)
jaserr(ctx, err)
... | func (a *ServerApiService) UpdateServerProfile(ctx context.Context, moid string) ApiUpdateServerProfileRequest {
return ApiUpdateServerProfileRequest{
ApiService: a,
ctx: ctx,
moid: moid,
}
} | func (sm *Statemgr) OnSecurityProfileDeleteReq(nodeID string, objinfo *netproto.SecurityProfile) error {
return nil
} | func (client *NimbusClient) diffSecurityProfilesDynamic(objList *netproto.SecurityProfileList, reactor SecurityProfileReactor,
ostream *AggWatchOStream, op diffOpType) {
// build a map of objects
objmap := make(map[string]*netproto.SecurityProfile)
if objList != nil {
for _, obj := range objList.SecurityProfiles ... | func (spi *SecurityProfileInformer) onAdd(sp *v1.SecurityProfile) {
// Check if running containers are selected by this SecurityProfile
spi.Nsp.DispatchEvent(&model.SecurityProfileCreatedEvent{
EventBase: model.EventBase{
EventType: model.SecurityProfileCreatedType,
EventMonitorName: model.SecurityProf... | func (s *NetworkService) UpdateNetworkAccessProfile(ctx context.Context, sid string, data url.Values) (*NetworkAccessProfile, error) {
networkAccessProfile := new(NetworkAccessProfile)
err := s.client.UpdateResource(ctx, napPathPart, sid, data, networkAccessProfile)
return networkAccessProfile, err
} | func (c *Client) HostPrivilegeElevationProfileUpdate(r string,payload *HostPrivilegeElevationProfileStruct) ( error) {
var err error
return err
} | func (r ApiUpdateServerProfileRequest) ServerProfile(serverProfile ServerProfile) ApiUpdateServerProfileRequest {
r.serverProfile = &serverProfile
return r
} | func (client *NetworkSecurityPolicyClient) Update(obj *models.NetworkSecurityPolicy) (*models.NetworkSecurityPolicy, error) {
var robj *models.NetworkSecurityPolicy
path := client.getAPIPath(obj.UUID)
err := client.aviSession.Put(path, obj, &robj)
return robj, err
} | func (s *Server) updateProfileFormula(c *gin.Context) {
accountNumber := c.GetString("requester")
var params struct {
Coefficient schema.ScoreCoefficient
}
if err := c.BindJSON(¶ms); err != nil {
abortWithEncoding(c, http.StatusBadRequest, errorInvalidParameters, err)
return
}
params.Coefficient.Upda... | func (r *AndroidPkcsCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidPkcsCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (ur *userRepository) UpdateProfile(ctx context.Context, user *model.User, firstName, lastName string, gender model.Gender, dateOfBirth null.Time) error {
user.FirstName = firstName
user.LastName = lastName
user.Gender = int64(gender)
user.DateOfBirth = mysql.NullTime{Time: dateOfBirth.Time, Valid: dateOfBirth.... | func (r *AndroidWorkProfilePkcsCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidWorkProfilePkcsCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (ac *APIController) NetprofileUpdate(profile, params *contivModel.Netprofile) error {
log.Infof("Received NetprofileUpdate: %+v, params: %+v", profile, params)
if params.Burst > 0 && params.Burst < 2 {
return core.Errorf("Invalid Burst size. burst size must be > 1500 bytes")
}
profile.Bandwidth = params.Ban... | func (c *Client) SecurityConfigUpdate(r string, payload *SecurityConfigStruct) error {
var err error
return err
} | func (r *AndroidForWorkScepCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidForWorkScepCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (userhandler *UserHandler) ChangeProfilePicture(response http.ResponseWriter, request *http.Request) {
response.Header().Set("Content-Type", "application/json")
var header *multipart.FileHeader
var erro error
var oldImage string
erro = request.ParseMultipartForm(99999999999)
if erro != nil {
response.Write... | func (i *FakeAgentAPI) HandleSecurityProfile(oper types.Operation, profile netproto.SecurityProfile) (profiles []netproto.SecurityProfile, err error) {
i.Lock()
defer i.Unlock()
err = utils.ValidateMeta(oper, profile.Kind, profile.ObjectMeta)
if err != nil {
log.Error(err)
return
}
// Handle Get and LIST. T... | func (d *DB) UpdateProfile(profile models.Profile) error {
defer d.Close()
sqlStatement := fmt.Sprint(`UPDATE contacts SET email=$2, first_name=$3, last_name=$4, phone=$5 WHERE id = $1`)
_, err := d.Exec(sqlStatement, profile.ID, profile.Email, profile.FirstName, profile.LastName, profile.Phone)
return err
} | func UpdateAdminProfile(stub shim.ChaincodeStubInterface, args []string) peer.Response {
if len(args) != 3 {
return createErrorResponse("Invalid number of arguments. Expected 3 argument.",
0,
nil)
}
queryIterator, queryError := stub.GetQueryResult("{\"selector\":{\"doc_type\":\"user\",\"_id\":\"" + args[0]... | func (u *User) UpdateStats(l config.Levels, g game.Game) {
u.updateGameStats(g)
userLevel := u.getUserLevel(l)
if userLevel.Level == u.LevelConfig.Level {
return
}
u.LevelConfig = userLevel
} | func (a *App) onUserProfileChange(userID string) {
syncService := a.Srv().GetSharedChannelSyncService()
if syncService == nil || !syncService.Active() {
return
}
syncService.NotifyUserProfileChanged(userID)
} | func UpdateProfile(id string, profile models.Profile) error {
profile.ID = id
err := validate.Struct(profile)
if err != nil {
return err
}
selector := database.QuerySelector{
"id": id,
}
err = db.Update("profiles", selector, &profile)
return err
} | func (eh *PolicerProfileTopic) updatePolicerProfileOper(oper *netproto.PolicerProfileEvent, nodeID string) error {
eh.updateAckedObjStatus(nodeID, oper.EventType, &oper.PolicerProfile.ObjectMeta)
switch oper.EventType {
case api.EventType_CreateEvent:
fallthrough
case api.EventType_UpdateEvent:
// incr stats
... | func UpdateProfilePicture(w http.ResponseWriter, r *http.Request) {
w.Header().Set("content-Type", "application/json")
org_collection, member_collection := "organizations", "members"
orgId := mux.Vars(r)["id"]
member_Id := mux.Vars(r)["mem_id"]
requestData := make(map[string]string)
if err := utils.ParseJsonFro... | func (e EndpointsSecurityV1Server) AutoUpdateFirewallProfile(ctx context.Context, in FirewallProfile) (FirewallProfile, error) {
resp, err := e.AutoUpdateFirewallProfileEndpoint(ctx, in)
if err != nil {
return FirewallProfile{}, err
}
return *resp.(*FirewallProfile), nil
} | func UpdateProfileEnd(c *fiber.Ctx) {
userID := userIDF(c.Get("token"))
var profileSave UpdateProfile
var baseUser BasicUser
if errorParse := c.BodyParser(&profileSave); errorParse != nil {
fmt.Println("Error parsing data", errorParse)
c.JSON(ErrorResponse{MESSAGE: "Error al parsear información"})
c.Status(4... | func (r *EndpointsSecurityV1RestClient) AutoUpdateFirewallProfile(ctx context.Context, in *FirewallProfile) (*FirewallProfile, error) {
path := makeURISecurityV1AutoUpdateFirewallProfileUpdateOper(in)
if r.bufferId != "" {
path = strings.Replace(path, "/configs", "/staging/"+r.bufferId, 1)
}
req, err := r.getHTTP... | func (r *AndroidForWorkPkcsCertificateProfileRequest) Update(ctx context.Context, reqObj *AndroidForWorkPkcsCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func ModifyProfile(user models.User, ID string) (bool, error) {
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
db := database.MongoCN.Database("yendo")
col := db.Collection("users")
register := make(map[string]interface{})
if len(user.Name) > 0 {
register["name"] = us... | func (r *Windows10PkcsCertificateProfileRequest) Update(ctx context.Context, reqObj *Windows10PkcsCertificateProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (a *ServerApiService) UpdateServerProfileExecute(r ApiUpdateServerProfileRequest) (*ServerProfile, *http.Response, error) {
var (
localVarHTTPMethod = http.MethodPost
localVarPostBody interface{}
formFiles []formFile
localVarReturnValue *ServerProfile
)
localBasePath, err := a.client.cfg.... | func (r *AndroidWorkProfileCertificateProfileBaseRequest) Update(ctx context.Context, reqObj *AndroidWorkProfileCertificateProfileBase) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | func (r *AndroidDeviceOwnerEnrollmentProfileRequest) Update(ctx context.Context, reqObj *AndroidDeviceOwnerEnrollmentProfile) error {
return r.JSONRequest(ctx, "PATCH", "", reqObj, nil)
} | [
"0.76793617",
"0.750683",
"0.7233263",
"0.71673733",
"0.6893227",
"0.6764657",
"0.67416286",
"0.6623206",
"0.657577",
"0.6519318",
"0.6404569",
"0.63953996",
"0.63524854",
"0.6347188",
"0.6325055",
"0.6323121",
"0.63084346",
"0.6304283",
"0.61996096",
"0.6189867",
"0.61445105... |
LoadSettings gets the relevant settings from the plugin context | func LoadSettings(ctx backend.PluginContext) (*DatasourceSettings, error) {
model := &DatasourceSettings{}
settings := ctx.DataSourceInstanceSettings
err := json.Unmarshal(settings.JSONData, &model)
if err != nil {
return nil, fmt.Errorf("error reading settings: %s", err.Error())
}
return model, nil
} | func LoadSettings(ctx backend.PluginContext) (*DatasourceSettings, error) {
model := &DatasourceSettings{}
settings := ctx.DataSourceInstanceSettings
err := json.Unmarshal(settings.JSONData, &model)
if err != nil {
return nil, fmt.Errorf("error reading settings: %s", err.Error())
}
model.PrivateKey, err = uti... | func LoadSettings(config backend.DataSourceInstanceSettings) (DatasourceSettings, error) {
settings := DatasourceSettings{}
if config.JSONData != nil && len(config.JSONData) > 1 {
if err := json.Unmarshal(config.JSONData, &settings); err != nil {
return settings, fmt.Errorf("could not unmarshal DatasourceSettin... | func LoadSettings() (*Settings, error) {
dbConfPath := droxolite.FindFilePath("domains.json", "conf")
content, err := ioutil.ReadFile(dbConfPath)
if err != nil {
return nil, err
}
settings := &Settings{}
err = json.Unmarshal(content, settings)
if err != nil {
return nil, err
}
return settings, nil
} | func LoadSettings() {
LoadFromConfigFile(&Settings, "config.yml")
} | func (wa *WebApp) LoadSettings(fn string) {
fr, err := ini.Load(fn)
if err != nil {
log.Fatal(err)
}
s := new(Settings)
err = fr.MapTo(s)
if err != nil {
log.Fatal(err)
}
wa.settings = s
} | func (sr *scrutinyRepository) LoadSettings(ctx context.Context) (*models.Settings, error) {
settingsEntries := []models.SettingEntry{}
if err := sr.gormClient.WithContext(ctx).Find(&settingsEntries).Error; err != nil {
return nil, fmt.Errorf("Could not get settings from DB: %v", err)
}
// store retrieved setting... | func (mgr *CrlWorkspaceManager) LoadSettings(trans *core.Transaction) error {
path := mgr.editor.getSettingsPath()
_, err := os.Stat(path)
if err != nil {
// it is OK to not find the file
mgr.editor.settings = &Settings{}
return nil
}
fileSettings, err2 := ioutil.ReadFile(path)
if err2 != nil {
return err... | func LoadSettings() (Settings, error) {
var s Settings
err := envconfig.Process("", &s)
return s, err
} | func LoadSettings() (settings *Settings) {
var data []byte
var err error
data, err = ioutil.ReadFile(DefaultSettingsFilename)
if err != nil {
return nil
}
err = json.Unmarshal(data, &settings)
if err != nil {
log.Println("Couldn't parse settings!")
return nil
}
err = settings.LoadKeys()
if err != nil {
... | func (t Bot) LoadSettings(filename string) (Configuration, error) {
configuration := Configuration{}
file, err := os.Open(filename)
if err != nil {
fmt.Println("FATAL: Unable to find file "+filename, err)
return configuration, err
}
decoder := json.NewDecoder(file)
err = decoder.Decode(&configuration)
if err... | func (t Bot) LoadSettings(filename string) (Configuration, error) {
configuration := Configuration{}
file, err := os.Open(filename)
if err != nil {
fmt.Println("FATAL: Unable to find file "+filename, err)
return configuration, err
}
decoder := json.NewDecoder(file)
err = decoder.Decode(&configuration)
if err... | func LoadSettings() {
s := &settings{
Database: "database.db",
ExportFolder: "export/",
}
Renderer = render.New(render.Options{IndentJSON: true})
cfg, err := ini.LooseLoad("settings.ini")
cfg.MapTo(s)
Settings = s
if err != nil {
fmt.Fprintf(os.Stderr, err.Error()+"\n")
os.Exit(1)
}
} | func (host *Host) loadSettings() error {
var settings *yaml.Yaml
file := host.DocumentRoot + pathSeparator + settingsFile
_, err := os.Stat(file)
if err == nil {
settings, err = yaml.Open(file)
if err != nil {
return fmt.Errorf(`Could not parse settings file (%s): %q`, file, err)
}
} else {
return f... | func Load() {
s := &Settings{}
f, err := os.Open(settingsFile)
if err != nil {
f, err := os.Create(settingsFile)
dlog.ErrorCheck(err)
s.SFXVolume = 1.0
s.MusicVolume = 1.0
s.MasterVolume = 1.0
data, err := json.Marshal(s)
dlog.ErrorCheck(err)
_, err = f.Write(data)
dlog.ErrorCheck(err)
} else {
... | func LoadSettings(ctx context.Context) (*sarama.Config, *commonconfig.EventingKafkaConfig, error) {
if ctx == nil {
return nil, nil, fmt.Errorf("attempted to load settings from a nil context")
}
configMap, err := kubeclient.Get(ctx).CoreV1().ConfigMaps(system.Namespace()).Get(ctx, commonconfig.SettingsConfigMapNa... | func LoadSettings(sys *cc.SysOption) (*Setting, error) {
if len(sys.ConfigFiles) == 0 {
return nil, errors.New("service's configuration file path is not configured")
}
// configure file is configured, then load configuration from file.
file, err := os.ReadFile(sys.ConfigFiles[0])
if err != nil {
return nil, f... | func LoadSettings(path string) {
// 1 - Default settings
LoadAppDefaultSettings()
// 2 - Specific file settings
if path != "" {
LoadFromFileSettings(path)
SpecificConfigPath = path
} else {
// 3 - Env var settings file
envSettingsFile := viper.GetString(SettingsPath)
if envSettingsFile != "" {
LoadF... | func LoadSettings(filename string) error {
//that's the main config file, panic if can't load
if err := utils.LoadTomlFile(filename, &Settings); err != nil {
return err
}
return nil
} | func (s *Server) loadSettings(filename string) error {
settingsFile, err := ioutil.ReadFile(filename)
if err != nil {
return fmt.Errorf("Error reading settings file: %s", err)
}
err = json.Unmarshal(settingsFile, &s.settings)
if err != nil {
return fmt.Errorf("Error unmarshaling settings: %s", err)
}
fmt.P... | func (shm *StorageHostManager) loadSettings() error {
// make directory
err := os.MkdirAll(shm.persistDir, 0700)
if err != nil {
return err
}
var persist persistence
persist.FilteredHosts = make(map[enode.ID]struct{})
err = common.LoadDxJSON(settingsMetadata, filepath.Join(shm.persistDir, PersistFilename), &... | func SettingsLoad(yamlFilePath string) (Settings, error) {
var s = Settings{}
filer, err := ioutil.ReadFile(yamlFilePath)
if err != nil {
return s, err
}
err = yaml.Unmarshal(filer, &s)
if err != nil {
return s, err
}
if len(s.Users) == 0 {
return s, errors.New("no valid users found in yaml file")
}
... | func GetSettings() map[string]string {
return settings
} | func (p *dcrdataPlugin) Settings() []backend.PluginSetting {
log.Tracef("dcrdata Settings")
return nil
} | func (v * VNode) loadNodeSettings() {
// Setup scribbler
dir := "./data/"
db, err := scribble.New(dir, nil)
if err != nil {
panic(err)
}
// Load settings
if err := db.Read("local", "config", &v.config); err != nil {
log.Println(err)
}
// Load registration
if err := db.Read("local", "registration", &v.r... | func (l *pluginLoader) loadPlugin(request *providers.PluginLoadRequest,
loadMethod func() (interface{}, interface{}, error)) (interface{}, error) {
pluginObject, settingsObject, err := loadMethod()
if err != nil {
return nil, err
}
if !reflect.TypeOf(pluginObject).AssignableTo(request.ExpectedType) {
return n... | func LoadSettings() *ConfigConn {
// crea una estructura de tipo ConfigConn nueva
c := new(ConfigConn)
//obtengo los parametros de la conexion del fichero config.json
raw, err := ioutil.ReadFile("config/connection/config.json")
//si hay error a la hora de leer.txt el fichero config.json termina el programa
if er... | func getSettings() (err error) {
settingsStr, err := ioutil.ReadFile("./settings.json")
err = json.Unmarshal(settingsStr, &appSettings)
if err != nil {
log.Printf("Error = %s\n", err)
return err
}
return err
} | func Load(path string) (*Settings, error) {
data, err := ioutil.ReadFile(filepath.Join(path, filename))
if err != nil {
return nil, fmt.Errorf("error reading settings file %s: %w", filepath.Join(path, filename), err)
}
var s Settings
if err := toml.Unmarshal(data, &s); err != nil {
return nil, fmt.Errorf("err... | func (s *suiteContext) Settings() *resource.Settings {
return s.settings
} | func ProviderSettingsFromContext(c echo.Context) *infrastructure.ProviderSettings {
settings := c.Get("_provider_settings")
if settings == nil {
return nil
}
return settings.(*infrastructure.ProviderSettings)
} | func (h *Handler) Settings() map[string]interface{} {
return h.settings
} | func GetSettings() *models.Settings {
return globalSettings
} | func (conf *PluginConfig) Read(values shared.MarshalMap) {
var err error
for key, settingValue := range values {
switch key {
case "ID":
conf.ID, err = values.String("ID")
case "Enable":
conf.Enable, err = values.Bool("Enable")
case "Instances":
conf.Instances, err = values.Int("Instances")
case... | func (ws *Workspace) Settings() (*Settings, error) {
if ws.settings != nil {
return ws.settings, nil
}
return ws.LoadSettings()
} | func GetSettings() *Settings {
viper.AutomaticEnv()
settings := Settings{
WebPort: viper.GetInt(strings.ToUpper(WebPort)),
GrpcPort: viper.GetInt(strings.ToUpper(GrpcPort)),
DatasinkGrpcPort: viper.GetInt(strings.ToUpper(DatasinkGrpcPort)),
RecognizersStoreGrpc... | func readSettings() Settings {
file, err := os.Open("conf.json")
if err != nil {
panic(err)
}
defer file.Close()
jParser := json.NewDecoder(file)
var s Settings
if err = jParser.Decode(&s); err != nil {
panic(err)
}
rs := strings.Split(s.Resolution, "x")
resW, err := strconv.Atoi(rs[0])
s.resW = float32... | func NewSettings() Settings {
settings := Settings{}
settings.settings = make(map[string]interface{})
settings.luaModules = make(map[string]lua.LGFunction)
return settings
} | func (m *BusinessFlow) GetSettings()(BusinessFlowSettingsable) {
val, err := m.GetBackingStore().Get("settings")
if err != nil {
panic(err)
}
if val != nil {
return val.(BusinessFlowSettingsable)
}
return nil
} | func LoadSettings(configFile string) (error error) {
error = nil
filename, err := filepath.Abs(configFile)
if err != nil {
fmt.Println("Fail find settings")
return err
}
yamlFile, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println("Fail open settings")
return err
}
err = yaml.Unmarshal(yamlFil... | func (base *LocalHandler_Base) LocalAPISettings() *LocalAPISettings {
return base.settings
} | func (se *StorageEndpoint) LoadResourceGroupSettings(f func(k, v string)) error {
return se.loadRangeByPrefix(resourceGroupSettingsPath+"/", f)
} | func Get() Settings {
Init()
return settings
} | func (s *BoltStore) SettingsGet() (*gaia.StoreConfig, error) {
var config = &gaia.StoreConfig{}
return config, s.db.View(func(tx *bolt.Tx) error {
// Get bucket
b := tx.Bucket(settingsBucket)
// Get pipeline
v := b.Get([]byte("gaia_config_settings"))
// Check if we found the pipeline
if v == nil {
r... | func LoadSettings(configFile string) (error error) {
error = nil
filename, err := filepath.Abs(configFile)
if err != nil {
fmt.Println("Fail find settings")
return err
}
yamlFile, err := ioutil.ReadFile(filename)
if err != nil {
fmt.Println("Fail open settings")
return err
}
err = yaml.Unmarshal(yamlFil... | func GetSettings() Settings {
var s Settings
flag.StringVar(&s.Auth.PublicKey, "auth-public-key", "", "Auth public key")
flag.StringVar(&s.Auth.PrivateKey, "auth-private-key", "", "Auth private key")
flag.StringVar(&s.ObjectStore.Bucket, "storage-bucket", "", "Storage bucket")
flag.StringVar(&s.ObjectStore.URL,... | func Load(path string) (Settings, error) {
var ret Settings
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
dec := json.NewDecoder(f)
if err := dec.Decode(&ret); err != nil {
return nil, err
}
return ret, nil
} | func GetSettings(c context.Context) *Settings {
set := Settings{}
switch err := settings.Get(c, baseName, &set); err {
case nil:
break
case settings.ErrNoSettings:
// Defaults.
set = defaultSettings
default:
panic(fmt.Errorf("could not fetch Archivist settings - %s", err))
}
return &set
} | func (c *Setting) load(settingFile string) error {
if _, err := os.Stat(settingFile); os.IsNotExist(err) {
return nil
}
data, err := ioutil.ReadFile(settingFile)
if os.IsNotExist(err) {
return err
}
err = yaml.Unmarshal(data, c)
if err != nil {
return err
}
if c.Info == nil {
c.Info = make(map[stri... | func LoadPlatformSettings(fileName string) PlatformSettings {
var config PlatformSettings
readConfig(fileName, &config)
return config
} | func LoadSettingsFromFile(path string) error {
settingLock.Lock()
defer settingLock.Unlock()
logger.LogInfo("Loading settings from file: %s \n", path)
cfgFile, ioErr := os.Open(path)
if ioErr != nil {
logger.LogError("Could not open configuration file! with error %s", ioErr.Error())
return ioErr
}
jsonDat... | func LoadFromFileSettings(path string) {
data, err := ioutil.ReadFile(path)
if err != nil {
log.Warningf("Error loading '%s' settings file", path)
} else {
viper.ReadConfig(bytes.NewBuffer(data))
SpecificConfigPath = path
}
} | func GetSettings() (*Settings, error) {
settings := &Settings{
Token: &models.AcessToken{},
}
data, err := readFile()
if err != nil {
return nil, errors.Wrapf(err, "get settings: reading file")
}
if len(data) == 0 {
return settings, nil
}
data, err = decrypt(data)
if err != nil {
return nil, errors.W... | func (pc *pathConfig) findAndLoadSettings(rootOrDeeper string) error {
root, err := findRoot(rootOrDeeper)
if err != nil {
return err
}
pc.root = root
settingsFile := filepath.Join(root, settingsFile)
s, err := unmarshalSettingsFile(settingsFile)
if err != nil {
return err
}
if err := pc.loadSettings(s)... | func (p *piPlugin) Settings() []backend.PluginSetting {
log.Tracef("pi Settings")
return []backend.PluginSetting{
{
Key: pi.SettingKeyTextFileSizeMax,
Value: strconv.FormatUint(uint64(p.textFileSizeMax), 10),
},
{
Key: pi.SettingKeyImageFileCountMax,
Value: strconv.FormatUint(uint64(p.imageFile... | func loadSettings(files []string) (map[string]interface{}, error) {
res := make(map[string]interface{})
for _, f := range files {
data, err := ioutil.ReadFile(f)
if err != nil {
return nil, errors.Wrapf(err, "failed to read settings file %s", f)
}
s := make(map[interface{}]interface{})
err = yaml.Unmarsh... | func readSettings(configFolder string, seqNum int) (pubSettingsJSON, protSettingsJSON map[string]interface{}, err error) {
cf := filepath.Join(configFolder, fmt.Sprintf("%d%s", seqNum, ".settings"))
pubSettingsJSON, protSettingsJSON, err = ReadSettings(cf)
err = errors.Wrapf(err, "error reading extension configurati... | func Get(settings settings.ISettings) pubsub.Settings {
return pubsub.Settings{
Provider: pubsub.ProviderType(settings.Get("Provider", string(pubsub.MemoryProvider))),
Google: getGoogleSettings(settings.GetSection("Google")),
Nats: getNatsSettings(settings.GetSection("Nats")),
}
} | func (sm *SettingsManager) load(client kubernetes.Interface) (configMap *v1.ConfigMap, isDifferent bool) {
configMap, err := client.CoreV1().ConfigMaps(args.Holder.GetNamespace()).
Get(context.TODO(), api.SettingsConfigMapName, metav1.GetOptions{})
if err != nil {
log.Printf("Cannot find settings config map: %s",... | func partialImportSettings(ctx context.Context, ss settings.Service, ff ...io.Reader) (err error) {
var (
// decoded content from YAML files
aux interface{}
si = settings.NewImporter()
// importer w/o permissions & roles
// we need only settings
imp = importer.NewImporter(nil, nil, nil, nil, nil, si)
... | func LoadDBSettings() (db Database, err error) {
// load setting database dari binaryfile/../config.json
_, filename, _, _ := runtime.Caller(1)
filepath := path.Join(path.Dir(filename), "/config.json")
jsonFile, err := os.Open(filepath)
defer jsonFile.Close()
if err != nil {
fmt.Println(err)
panic(err)
}
//... | func (sm *SettingsManager) load(client kubernetes.Interface) (configMap *v1.ConfigMap, isDifferent bool) {
configMap, err := client.CoreV1().ConfigMaps(args.Holder.GetNamespace()).
Get(api.SettingsConfigMapName, metav1.GetOptions{})
if err != nil {
log.Printf("Cannot find settings config map: %s", err.Error())
... | func (s *Settings) Load() error {
folder, err := getConfigFolder()
if err != nil {
return err
}
f, err := os.Open(folder + "claws.json")
if err != nil {
// silently ignore ErrNotExist
if os.IsNotExist(err) {
return nil
}
return err
}
defer f.Close()
return json.NewDecoder(f).Decode(s)
} | func (c *Credential) LoadSetting() error {
err := c.Loader.Load(c.Path, &c.AppSetting)
if err == nil {
if c.checkersList[SettingTW] {
if err = c.AppSetting.TwitchSettings.Check(); err != nil {
return err
}
}
if c.checkersList[SettingDB] {
for _, database := range c.AppSetting.Databases {
if er... | func LoadSettingsByEnv(env string) {
configFile := GetExecDirectory() + "/settings.json"
content, err := ioutil.ReadFile(configFile)
if err != nil {
fmt.Println("Error while reading config file", err)
}
settings = Settings{}
jsonErr := json.Unmarshal(content, &settings)
if jsonErr != nil {
fmt.Println("Error... | func ReadSettings() (err error) {
data, err := ioutil.ReadFile(SettingsPath)
if err != nil {
return
}
err = json.Unmarshal(data, &Settings)
return
} | func (w *ServerInterfaceWrapper) GetUserSettings(ctx echo.Context) error {
var err error
// ------------- Path parameter "userID" -------------
var userID UserID
err = runtime.BindStyledParameter("simple", false, "userID", ctx.Param("userID"), &userID)
if err != nil {
return echo.NewHTTPError(http.StatusBadRequ... | func setupSettings() {
// check `--log-level`
switch utils.Settings.GetString("log-level") {
case "debug":
case "info":
case "warn":
case "error":
default:
panic(fmt.Sprintf("unknown value `--log-level=%v`", utils.Settings.GetString("log-level")))
}
// check `--env`
// switch utils.Settings.GetString("env"... | func TestPluginConfigRead(t *testing.T) {
expect := shared.NewExpect(t)
mockPluginCfg := getMockPluginConfig()
// create a mock MarshalMap
testMarshalMap := shared.NewMarshalMap()
testMarshalMap["Instances"] = 0
mockPluginCfg.Read(testMarshalMap)
// with 0 instance, plugin should be disabled
expect.False(mock... | func (c *ConfigManager) parseSettingsFile(path string) (*Settings, error) {
settings := &Settings{}
b, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
if err := goyaml.Unmarshal(b, settings); err != nil {
return nil, err
}
Log.Infof("Loaded settings file: '%+v'", path)
return settings, nil
} | func grabSettings() GeneralSettings {
settingsJson, err := ioutil.ReadFile("settings/general.json")
if err != nil {
fmt.Print(err)
}
var data GeneralSettings
err = json.Unmarshal(settingsJson, &data)
if err != nil {
fmt.Println("error:", err)
}
return data
} | func Settings(path string) map[string]string {
jsonConf := LoadJSONConfig(path)
dbConfig := LoadYamlConfig(jsonConf.Database_file)
environment := jsonConf.Environment
return dbConfig[environment]
} | func (s *Server) loadConfig(c *cli.Context) {
s.cfg.LoadSettings(c)
} | func (s *Setting) Load() (err error) {
v.AddConfigPath(".")
v.SetConfigName("config")
v.SetConfigType("toml")
err = v.ReadInConfig()
if err != nil {
err = errors.Wrap(err, "v.ReadInConfig")
return
}
err = v.UnmarshalExact(s)
if err != nil {
err = errors.Wrap(err, "v.UnmarshalExact")
return
}
info, err... | func getSettings(settingsFile string) (applicationSettings, error) {
fullPath, err := filepath.Abs(settingsFile)
if err != nil {
return applicationSettings{}, err
}
data, err := ioutil.ReadFile(fullPath)
if err != nil {
return applicationSettings{}, err
}
var settings settingsJSON
err = json.Unmarshal(dat... | func (pc *pathConfig) loadSettings(s Settings) error {
for _, m := range s.Mappings {
l, err := pathmap.NewMapper(m.Local)
if err != nil {
return err
}
c, err := pathmap.NewMapper(m.VName.Corpus)
if err != nil {
return err
}
p, err := pathmap.NewMapper(m.VName.Path)
if err != nil {
return e... | func loadConfig() {
} | func Read() Settings {
// setup config file read context
SetConfContext()
var Settings Settings
if err := viper.ReadInConfig(); err != nil {
fmt.Printf("Error reading config file, %s", err)
}
// Set undefined variables
err := viper.Unmarshal(&Settings)
if err != nil {
fmt.Printf("Unable to decode into str... | func load() {
loadConfig()
storageInstance()
} | func (i *ImportSettings) GetImportSettings() *ImportSettings { return i } | func (s *settingsProvider) PluginLoader() providers.IPluginLoaderProvider {
return s.pluginLoader
} | func Get() Settings {
if !settings.isset {
Init()
}
return settings
} | func (st *Stage) Settings() *config.Settings {
return st.settings
} | func LoadContainerSettings(base *Container, inc *Container, meta *toml.MetaData, key ...string) {
if meta.IsDefined(append(key, "command")...) {
base.Command = inc.Command
}
if meta.IsDefined(append(key, "folder")...) {
base.Folder = inc.Folder
}
if meta.IsDefined(append(key, "privileged")...) {
base.Priv... | func Load(filename string) (settings map[string]string, e os.Error) {
settings = make(map[string]string, 10)
fileContents, e := ioutil.ReadFile(filename)
if e != nil {
dlog.Printf("Failed to read %s, %s.\n", filename, e)
return
}
lines := bytes.Split(fileContents, []byte("\n"), -1)
for _, line := range(lines)... | func (cs *ConfigurationStorage) LoadServerSettings(ss *model.ServerSettings) error {
dir, err := os.Getwd()
if err != nil {
return fmt.Errorf("Cannot get server configuration file: %s", err)
}
yamlFile, err := ioutil.ReadFile(filepath.Join(dir, ss.ConfigurationStorage.SettingsKey))
if err != nil {
return fmt.... | func (plugin *Plugin) LoadPluginExtenstions() error {
err := plugin.VM.Set("getChecksum", func(content string) string {
return services.GetSha1Checksum(content)
})
if err != nil {
return err
}
err = plugin.VM.Set("log", func(message string) {
log.Printf("[%s] %s", plugin.Name, message)
})
if err != nil {
... | func (c *Config) loadFromEnv() {
// Make sure the server id looks presentable.
c.ServerID = GetEnv("WPARK_SERVER_ID", "wpark-server-1")
c.Host = GetEnv("WPARK_CORE_API_HOST", "localhost")
c.Port = GetEnvAsInt("WPARK_CORE_API_PORT", 11111)
c.IsProduction = GetEnv("WPARK_PRODUCTION", "") != ""
c.MySQLURL = GetEnv... | func GetSettings(a Account) (Settings, error) {
s, err := persistenceInstance.settings(a)
if err != nil {
return s, err
}
return s, nil
} | func (h *handler) Settings(w http.ResponseWriter, r *http.Request) {
apiReq, err := http.NewRequest("GET", h.serverAddress+"/settings", nil)
if err != nil {
serverError(w, err)
return
}
tokenCookie, err := r.Cookie("socialnet_token")
if err != nil {
serverError(w, err)
return
}
apiReq.Header.Set("Autho... | func GetSettings(configPath string) (Settings, error) {
var config Settings
ioConfig, err := ioutil.ReadFile(configPath)
if err != nil {
return config, err
}
err = json.Unmarshal(ioConfig, &config)
if err != nil {
return config, err
}
return config, nil
} | func (hs *HTTPServer) getFrontendSettings(c *contextmodel.ReqContext) (*dtos.FrontendSettingsDTO, error) {
availablePlugins, err := hs.availablePlugins(c.Req.Context(), c.OrgID)
if err != nil {
return nil, err
}
apps := make(map[string]*plugins.AppDTO, 0)
for _, ap := range availablePlugins[plugins.App] {
app... | func (this *Settings) LoadJSON(b []byte) error {
var newSettings map[string]interface{}
err := json.Unmarshal(b, &newSettings)
if err != nil {
return err
}
return this.MergeSettings(newSettings)
} | func (settings *SettingsData) Read() {
fileData, err := ioutil.ReadFile(settingsFile)
if err != nil {
log.Fatal(err)
}
if err := xml.Unmarshal(fileData, settings); err != nil {
log.Fatal(err)
}
if settings.MaxFPS == 0 {
settings.MaxFPS = 60
}
// setup any derived values
settings.MinFrameTime = 1.0 / s... | func Config(ctx *context.Context) {
ctx.Data["Title"] = ctx.Tr("admin.config")
ctx.Data["PageIsAdminConfig"] = true
systemSettings, err := system_model.GetAllSettings(ctx)
if err != nil {
ctx.ServerError("system_model.GetAllSettings", err)
return
}
// All editable settings from UI
ctx.Data["SystemSettings"... | func SetSettings(settings *models.Settings) {
globalSettings = settings
} | func (c *ConfigManager) Load() {
for _, v := range c.Options {
v.LoadValue()
}
} | func (a *Action) Settings() map[string]interface{} {
return a.settings
} | func GetGlobalSettings() (*Config, error) {
settingsJSONContents, err := ioutil.ReadFile(GetGlobalSettingsFile())
if err != nil {
return nil, err
}
config := Config{}
err = json.Unmarshal(settingsJSONContents, &config)
if err != nil {
return nil, err
}
return &config, nil
} | func (m *Module) GetSettings() *ModuleSettings {
return m.Settings
} | func loadPluginstoreFromKvstore() error {
err := pluginStore.kvstore.GetAll(store.Plugin_instances_bucket, saveToStore)
if err != nil {
return fmt.Errorf("Failed to save to store : %v", err)
}
return nil
} | [
"0.72158736",
"0.62308687",
"0.6162338",
"0.6140012",
"0.61189824",
"0.6084855",
"0.6061291",
"0.59076136",
"0.5907558",
"0.589246",
"0.589246",
"0.5878979",
"0.5832849",
"0.58122665",
"0.57541615",
"0.5736124",
"0.5719982",
"0.5668884",
"0.56484413",
"0.5609903",
"0.5578986"... |
Takes the result of flatmap.Expand for an array of step adjustments and returns a []autoscaling.StepAdjustment. | func ExpandStepAdjustments(configured []interface{}) ([]*autoscaling.StepAdjustment, error) {
var adjustments []*autoscaling.StepAdjustment
// Loop over our configured step adjustments and create an array
// of aws-sdk-go compatible objects. We're forced to convert strings
// to floats here because there's no way ... | func FlattenStepAdjustments(adjustments []*autoscaling.StepAdjustment) []map[string]interface{} {
result := make([]map[string]interface{}, 0, len(adjustments))
for _, raw := range adjustments {
a := map[string]interface{}{
"scaling_adjustment": aws.Int64Value(raw.ScalingAdjustment),
}
if raw.MetricIntervalUp... | func expandPatchDeploymentPatchConfigPreStepSlice(c *Client, f []PatchDeploymentPatchConfigPreStep) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigPreStep(c, &item)
if err != nil {
r... | func expandPatchDeploymentRolloutSlice(c *Client, f []PatchDeploymentRollout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRollout(c, &item)
if err != nil {
return nil, err
}
items = app... | func expandPatchDeploymentRolloutDisruptionBudgetSlice(c *Client, f []PatchDeploymentRolloutDisruptionBudget) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRolloutDisruptionBudget(c, &item)
if er... | func expandVersionAutomaticScalingSlice(c *Client, f []VersionAutomaticScaling) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScaling(c, &item)
if err != nil {
return nil, err
}
items = ... | func expandPatchDeploymentPatchConfigPostStepSlice(c *Client, f []PatchDeploymentPatchConfigPostStep) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigPostStep(c, &item)
if err != nil {
... | func flattenPatchDeploymentPatchConfigPreStepSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStep {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStep{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPreStep{}
}
items := make([]PatchDeploymentPatchConfigPreS... | func expandPatchDeploymentPatchConfigAptSlice(c *Client, f []PatchDeploymentPatchConfigApt) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigApt(c, &item)
if err != nil {
return nil, e... | func expandVersionManualScalingSlice(c *Client, f []VersionManualScaling) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionManualScaling(c, &item)
if err != nil {
return nil, err
}
items = append(it... | func expandPatchDeploymentOneTimeScheduleSlice(c *Client, f []PatchDeploymentOneTimeSchedule) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentOneTimeSchedule(c, &item)
if err != nil {
return nil... | func expandAutoscalerAutoscalingPolicySlice(c *Client, f []AutoscalerAutoscalingPolicy) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerAutoscalingPolicy(c, &item)
if err != nil {
return nil, err
}... | func expandPatchDeploymentPatchConfigWindowsUpdateSlice(c *Client, f []PatchDeploymentPatchConfigWindowsUpdate) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigWindowsUpdate(c, &item)
if... | func expandPatchDeploymentRecurringScheduleMonthlySlice(c *Client, f []PatchDeploymentRecurringScheduleMonthly) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRecurringScheduleMonthly(c, &item)
if... | func expandVersionJobScalingSlice(c *Client, f []VersionJobScaling) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionJobScaling(c, &item)
if err != nil {
return nil, err
}
items = append(items, i)
... | func flattenPatchDeploymentPatchConfigPostStepSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStep {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStep{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPostStep{}
}
items := make([]PatchDeploymentPatchConfig... | func expandVersionAutomaticScalingRequestUtilizationSlice(c *Client, f []VersionAutomaticScalingRequestUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScalingRequestUtilization(c, &item... | func expandPatchDeploymentPatchConfigSlice(c *Client, f []PatchDeploymentPatchConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfig(c, &item)
if err != nil {
return nil, err
}
... | func expandAutoscalerAutoscalingPolicyScaleInControlSlice(c *Client, f []AutoscalerAutoscalingPolicyScaleInControl) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerAutoscalingPolicyScaleInControl(c, &item... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigSlice(c *Client, f []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConf... | func expandAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasSlice(c *Client, f []AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerAu... | func expandDashboardTabbedLayoutTabsRowLayoutSlice(c *Client, f []DashboardTabbedLayoutTabsRowLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayoutTabsRowLayout(c, &item)
if err != nil {
... | func expandAutoscalerStatusDetailsSlice(c *Client, f []AutoscalerStatusDetails) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerStatusDetails(c, &item)
if err != nil {
return nil, err
}
items = ... | func expandVersionPoolScalingSlice(c *Client, f []VersionPoolScaling) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionPoolScaling(c, &item)
if err != nil {
return nil, err
}
items = append(items, i... | func expandPatchDeploymentPatchConfigYumSlice(c *Client, f []PatchDeploymentPatchConfigYum) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigYum(c, &item)
if err != nil {
return nil, e... | func expandPatchDeploymentRecurringScheduleSlice(c *Client, f []PatchDeploymentRecurringSchedule) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRecurringSchedule(c, &item)
if err != nil {
retu... | func flattenPatchDeploymentPatchConfigAptSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigApt {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigApt{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigApt{}
}
items := make([]PatchDeploymentPatchConfigApt, 0, len(a))
for... | func expandVersionAutomaticScalingStandardSchedulerSettingsSlice(c *Client, f []VersionAutomaticScalingStandardSchedulerSettings) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScalingStandardSched... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConf... | func expandPatchDeploymentRecurringScheduleWeeklySlice(c *Client, f []PatchDeploymentRecurringScheduleWeekly) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRecurringScheduleWeekly(c, &item)
if er... | func expandPatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthSlice(c *Client, f []PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonth) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRecurringSc... | func expandPatchDeploymentInstanceFilterSlice(c *Client, f []PatchDeploymentInstanceFilter) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentInstanceFilter(c, &item)
if err != nil {
return nil, e... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigSlice(c *Client, f []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchCo... | func expandVersionAutomaticScalingDiskUtilizationSlice(c *Client, f []VersionAutomaticScalingDiskUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScalingDiskUtilization(c, &item)
if er... | func flattenVersionAutomaticScalingSlice(c *Client, i interface{}) []VersionAutomaticScaling {
a, ok := i.([]interface{})
if !ok {
return []VersionAutomaticScaling{}
}
if len(a) == 0 {
return []VersionAutomaticScaling{}
}
items := make([]VersionAutomaticScaling, 0, len(a))
for _, item := range a {
items ... | func expandDashboardRowLayoutSlice(c *Client, f []DashboardRowLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardRowLayout(c, &item)
if err != nil {
return nil, err
}
items = append(items, i... | func flattenPatchDeploymentPatchConfigWindowsUpdateClassificationsEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigWindowsUpdateClassificationsEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigWindowsUpdateClassificationsEnum{}
}
if len(a) == 0 {
return []PatchDeploym... | func expandDashboardTabbedLayoutTabsRowLayoutRowsSlice(c *Client, f []DashboardTabbedLayoutTabsRowLayoutRows) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayoutTabsRowLayoutRows(c, &item)
if er... | func expandDeliveryPipelineSerialPipelineStagesSlice(c *Client, f []DeliveryPipelineSerialPipelineStages, res *DeliveryPipeline) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDeliveryPipelineSerialPipelineStages(... | func flattenAutoscalerAutoscalingPolicySlice(c *Client, i interface{}) []AutoscalerAutoscalingPolicy {
a, ok := i.([]interface{})
if !ok {
return []AutoscalerAutoscalingPolicy{}
}
if len(a) == 0 {
return []AutoscalerAutoscalingPolicy{}
}
items := make([]AutoscalerAutoscalingPolicy, 0, len(a))
for _, item :... | func flattenAutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicasSlice(c *Client, i interface{}) []AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas {
a, ok := i.([]interface{})
if !ok {
return []AutoscalerAutoscalingPolicyScaleInControlMaxScaledInReplicas{}
}
if len(a) == 0 {
return []Autosc... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectSlice(c *Client, f []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchD... | func expandDashboardTabbedLayoutSlice(c *Client, f []DashboardTabbedLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayout(c, &item)
if err != nil {
return nil, err
}
items = append... | func expandVersionAutomaticScalingCpuUtilizationSlice(c *Client, f []VersionAutomaticScalingCpuUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScalingCpuUtilization(c, &item)
if err !... | func expandVersionBasicScalingSlice(c *Client, f []VersionBasicScaling) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionBasicScaling(c, &item)
if err != nil {
return nil, err
}
items = append(items... | func expandPatchDeploymentPatchConfigGooSlice(c *Client, f []PatchDeploymentPatchConfigGoo) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigGoo(c, &item)
if err != nil {
return nil, e... | func expandAutoscalerAutoscalingPolicyLoadBalancingUtilizationSlice(c *Client, f []AutoscalerAutoscalingPolicyLoadBalancingUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerAutoscalingPolicyLoa... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnum{}
}
if len(... | func expandVersionDeploymentSlice(c *Client, f []VersionDeployment) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionDeployment(c, &item)
if err != nil {
return nil, err
}
items = append(items, i)
... | func flattenPatchDeploymentPatchConfigWindowsUpdateSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigWindowsUpdate {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigWindowsUpdate{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigWindowsUpdate{}
}
items := make([]PatchD... | func flattenPatchDeploymentRecurringScheduleMonthlySlice(c *Client, i interface{}) []PatchDeploymentRecurringScheduleMonthly {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRecurringScheduleMonthly{}
}
if len(a) == 0 {
return []PatchDeploymentRecurringScheduleMonthly{}
}
items := make([]PatchD... | func expandVersionHealthCheckSlice(c *Client, f []VersionHealthCheck) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionHealthCheck(c, &item)
if err != nil {
return nil, err
}
items = append(items, i... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchC... | func expandLogMetricMetricDescriptorMetadataIngestDelaySlice(c *Client, f []LogMetricMetricDescriptorMetadataIngestDelay) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandLogMetricMetricDescriptorMetadataIngestDelay... | func expandPatchDeploymentRecurringScheduleTimeOfDaySlice(c *Client, f []PatchDeploymentRecurringScheduleTimeOfDay) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentRecurringScheduleTimeOfDay(c, &item... | func flattenAutoscalerAutoscalingPolicyScaleInControlSlice(c *Client, i interface{}) []AutoscalerAutoscalingPolicyScaleInControl {
a, ok := i.([]interface{})
if !ok {
return []AutoscalerAutoscalingPolicyScaleInControl{}
}
if len(a) == 0 {
return []AutoscalerAutoscalingPolicyScaleInControl{}
}
items := make(... | func expandInstanceBundlesConfigSlice(c *Client, f []InstanceBundlesConfig, res *Instance) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandInstanceBundlesConfig(c, &item, res)
if err != nil {
return nil, err
... | func expandDashboardRowLayoutRowsSlice(c *Client, f []DashboardRowLayoutRows) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardRowLayoutRows(c, &item)
if err != nil {
return nil, err
}
items = app... | func expandVersionHandlersApiEndpointSlice(c *Client, f []VersionHandlersApiEndpoint) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionHandlersApiEndpoint(c, &item)
if err != nil {
return nil, err
}
... | func flattenPatchDeploymentRolloutDisruptionBudgetSlice(c *Client, i interface{}) []PatchDeploymentRolloutDisruptionBudget {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRolloutDisruptionBudget{}
}
if len(a) == 0 {
return []PatchDeploymentRolloutDisruptionBudget{}
}
items := make([]PatchDeplo... | func expandCaPoolIssuancePolicyBaselineValuesAdditionalExtensionsSlice(c *Client, f []CaPoolIssuancePolicyBaselineValuesAdditionalExtensions, res *CaPool) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandCaPoolIssua... | func expandDashboardTabbedLayoutTabsGridLayoutSlice(c *Client, f []DashboardTabbedLayoutTabsGridLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayoutTabsGridLayout(c, &item)
if err != nil ... | func expandLakeAssetStatusSlice(c *Client, f []LakeAssetStatus, res *Lake) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandLakeAssetStatus(c, &item, res)
if err != nil {
return nil, err
}
items = append(i... | func flattenPatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthSlice(c *Client, i interface{}) []PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonth {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonth{}
}
if len(a) == 0 {
return []PatchDeploymentRecurringSch... | func expandPatchDeploymentPatchConfigPreStepLinuxExecStepConfigSlice(c *Client, f []PatchDeploymentPatchConfigPreStepLinuxExecStepConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigPr... | func flattenLogMetricMetricDescriptorMetadataLaunchStageEnumSlice(c *Client, i interface{}) []LogMetricMetricDescriptorMetadataLaunchStageEnum {
a, ok := i.([]interface{})
if !ok {
return []LogMetricMetricDescriptorMetadataLaunchStageEnum{}
}
if len(a) == 0 {
return []LogMetricMetricDescriptorMetadataLaunchSta... | func expandAutoscalerAutoscalingPolicyCpuUtilizationSlice(c *Client, f []AutoscalerAutoscalingPolicyCpuUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandAutoscalerAutoscalingPolicyCpuUtilization(c, &item... | func flattenPatchDeploymentPatchConfigRebootConfigEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigRebootConfigEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigRebootConfigEnum{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigRebootConfigEnum{}
}
items := m... | func expandEndpointPolicyEndpointMatcherSlice(c *Client, f []EndpointPolicyEndpointMatcher, res *EndpointPolicy) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandEndpointPolicyEndpointMatcher(c, &item, res)
if err... | func flattenPatchDeploymentOneTimeScheduleSlice(c *Client, i interface{}) []PatchDeploymentOneTimeSchedule {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentOneTimeSchedule{}
}
if len(a) == 0 {
return []PatchDeploymentOneTimeSchedule{}
}
items := make([]PatchDeploymentOneTimeSchedule, 0, len(a))... | func expandDashboardTabbedLayoutTabsSlice(c *Client, f []DashboardTabbedLayoutTabs) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayoutTabs(c, &item)
if err != nil {
return nil, err
}
it... | func (ac ArtifactsConfig) Expand(appDirectory string) []ArtifactsConfig {
// check for shorthand configuration and return its expanded form
if ac.From != "" && ac.Source == "" && ac.Destination == "" {
if ac.From == LocalArtifactKeyword {
return []ArtifactsConfig{
{
From: ac.From,
Source: ... | func expandVersionAutomaticScalingNetworkUtilizationSlice(c *Client, f []VersionAutomaticScalingNetworkUtilization) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionAutomaticScalingNetworkUtilization(c, &item... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObjectSlice(c *Client, f []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatc... | func expandInstanceManagementConfigSlice(c *Client, f []InstanceManagementConfig, res *Instance) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandInstanceManagementConfig(c, &item, res)
if err != nil {
return n... | func expandCaPoolIssuancePolicyPassthroughExtensionsSlice(c *Client, f []CaPoolIssuancePolicyPassthroughExtensions, res *CaPool) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandCaPoolIssuancePolicyPassthroughExtens... | func flattenLogMetricMetricDescriptorLaunchStageEnumSlice(c *Client, i interface{}) []LogMetricMetricDescriptorLaunchStageEnum {
a, ok := i.([]interface{})
if !ok {
return []LogMetricMetricDescriptorLaunchStageEnum{}
}
if len(a) == 0 {
return []LogMetricMetricDescriptorLaunchStageEnum{}
}
items := make([]Lo... | func (es Elevators) Flatten()([][]int){
var slice [][]int
for _, elevator := range es {
// type assertion for slices from interface{} to int
goals := make([]int, elevator.goalFloors.Size())
for i, floor := range elevator.goalFloors.List() { goals[i] = floor.(int) }
elevatorStatus := []int{e... | func flattenPatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthDayOfWeekEnumSlice(c *Client, i interface{}) []PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthDayOfWeekEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthDayOfWeekEnum{}
}
if len(a) == 0 {... | func flattenPatchDeploymentRolloutSlice(c *Client, i interface{}) []PatchDeploymentRollout {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRollout{}
}
if len(a) == 0 {
return []PatchDeploymentRollout{}
}
items := make([]PatchDeploymentRollout, 0, len(a))
for _, item := range a {
items = app... | func expandVersionInstanceSpecPortsSlice(c *Client, f []VersionInstanceSpecPorts) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionInstanceSpecPorts(c, &item)
if err != nil {
return nil, err
}
items... | func expandInstanceManagementConfigStandardManagementConfigSlice(c *Client, f []InstanceManagementConfigStandardManagementConfig, res *Instance) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandInstanceManagementCon... | func expandDashboardTabbedLayoutTabsMosaicLayoutSlice(c *Client, f []DashboardTabbedLayoutTabsMosaicLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardTabbedLayoutTabsMosaicLayout(c, &item)
if err !... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepLinuxExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepLinuxExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPreS... | func flattenPatchDeploymentPatchConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfig{}
}
items := make([]PatchDeploymentPatchConfig, 0, len(a))
for _, item := ran... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnum{}
}
if len(a) == ... | func expandLakeMetastoreStatusSlice(c *Client, f []LakeMetastoreStatus, res *Lake) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandLakeMetastoreStatus(c, &item, res)
if err != nil {
return nil, err
}
item... | func flattenPatchDeploymentPatchConfigYumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigYum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigYum{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigYum{}
}
items := make([]PatchDeploymentPatchConfigYum, 0, len(a))
for... | func expandVersionDeploymentContainerSlice(c *Client, f []VersionDeploymentContainer) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionDeploymentContainer(c, &item)
if err != nil {
return nil, err
}
... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnum{}
}
if l... | func expandPatchDeploymentPatchConfigZypperSlice(c *Client, f []PatchDeploymentPatchConfigZypper) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigZypper(c, &item)
if err != nil {
retu... | func expandCaPoolIssuancePolicyBaselineValuesSlice(c *Client, f []CaPoolIssuancePolicyBaselineValues, res *CaPool) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandCaPoolIssuancePolicyBaselineValues(c, &item, res)
... | func expandVersionHandlersSlice(c *Client, f []VersionHandlers) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandVersionHandlers(c, &item)
if err != nil {
return nil, err
}
items = append(items, i)
}
re... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject{}
}
if len(a) == 0 {
return... | func flattenPatchDeploymentRecurringScheduleSlice(c *Client, i interface{}) []PatchDeploymentRecurringSchedule {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRecurringSchedule{}
}
if len(a) == 0 {
return []PatchDeploymentRecurringSchedule{}
}
items := make([]PatchDeploymentRecurringSchedule, ... | func expandDashboardMosaicLayoutSlice(c *Client, f []DashboardMosaicLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardMosaicLayout(c, &item)
if err != nil {
return nil, err
}
items = append... | func expandSpokeLinkedRouterApplianceInstancesSlice(c *Client, f []SpokeLinkedRouterApplianceInstances, res *Spoke) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandSpokeLinkedRouterApplianceInstances(c, &item, res)... | func expandDashboardWidgetScorecardTimeSeriesQueryTimeSeriesFilterRatioNumeratorSlice(c *Client, f []DashboardWidgetScorecardTimeSeriesQueryTimeSeriesFilterRatioNumerator) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := ... | func flattenVersionAutomaticScalingRequestUtilizationSlice(c *Client, i interface{}) []VersionAutomaticScalingRequestUtilization {
a, ok := i.([]interface{})
if !ok {
return []VersionAutomaticScalingRequestUtilization{}
}
if len(a) == 0 {
return []VersionAutomaticScalingRequestUtilization{}
}
items := make(... | func flattenPatchDeploymentRecurringScheduleWeeklySlice(c *Client, i interface{}) []PatchDeploymentRecurringScheduleWeekly {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentRecurringScheduleWeekly{}
}
if len(a) == 0 {
return []PatchDeploymentRecurringScheduleWeekly{}
}
items := make([]PatchDeplo... | func expandDashboardGridLayoutSlice(c *Client, f []DashboardGridLayout) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandDashboardGridLayout(c, &item)
if err != nil {
return nil, err
}
items = append(items... | [
"0.6933056",
"0.56839454",
"0.56170374",
"0.54817635",
"0.54315895",
"0.5384485",
"0.5343031",
"0.53271675",
"0.5255032",
"0.5253832",
"0.5222788",
"0.51889306",
"0.5176776",
"0.5159237",
"0.5155685",
"0.5109404",
"0.5101826",
"0.51007044",
"0.50971985",
"0.50388354",
"0.5026... |
Flattens step adjustments into a list of map[string]interface. | func FlattenStepAdjustments(adjustments []*autoscaling.StepAdjustment) []map[string]interface{} {
result := make([]map[string]interface{}, 0, len(adjustments))
for _, raw := range adjustments {
a := map[string]interface{}{
"scaling_adjustment": aws.Int64Value(raw.ScalingAdjustment),
}
if raw.MetricIntervalUp... | func flattenPatchDeploymentPatchConfigPreStepMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStep {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStep{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigPreStep{}
}
items := mak... | func flattenPatchDeploymentPatchConfigPostStepMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStep {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStep{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigPostStep{}
}
items :=... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfig{}
}
if len(a) == 0 {
return m... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfig{}
}
if len(a) == 0 {
retur... | func ExpandStepAdjustments(configured []interface{}) ([]*autoscaling.StepAdjustment, error) {
var adjustments []*autoscaling.StepAdjustment
// Loop over our configured step adjustments and create an array
// of aws-sdk-go compatible objects. We're forced to convert strings
// to floats here because there's no way ... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfig{}
}
if len(a) == 0 {
return map[str... | func flattenPatchDeploymentPatchConfigPostStepLinuxExecStepConfigMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfig{}
}
if len(a) == 0 {
return map[... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject{}
}
... | func flattenPatchDeploymentPatchConfigPreStepSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStep {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStep{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPreStep{}
}
items := make([]PatchDeploymentPatchConfigPreS... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObjectMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject{}
}... | func flattenPatchDeploymentPatchConfigPostStepSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStep {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStep{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPostStep{}
}
items := make([]PatchDeploymentPatchConfig... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObjectMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject{}
}
if len... | func flattenPatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObjectMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObject {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObject{}
}
if ... | func expandPatchDeploymentPatchConfigPreStepMap(c *Client, f map[string]PatchDeploymentPatchConfigPreStep) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentPatchConfigPreStep(c, &item)
if err != nil... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInter... | func flattenPatchDeploymentRolloutMap(c *Client, i interface{}) map[string]PatchDeploymentRollout {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRollout{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRollout{}
}
items := make(map[string]PatchDeploymentRollout)
for k,... | func expandPatchDeploymentPatchConfigPreStepSlice(c *Client, f []PatchDeploymentPatchConfigPreStep) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigPreStep(c, &item)
if err != nil {
r... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreter... | func flattenPatchDeploymentPatchConfigAptMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigApt {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigApt{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigApt{}
}
items := make(map[string]Pat... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfigIn... | func expandPatchDeploymentPatchConfigPostStepMap(c *Client, f map[string]PatchDeploymentPatchConfigPostStep) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentPatchConfigPostStep(c, &item)
if err != ... | func flattenPatchDeploymentPatchConfigPreStep(c *Client, i interface{}) *PatchDeploymentPatchConfigPreStep {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &PatchDeploymentPatchConfigPreStep{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyPatchDeploymentPatchConfigPreStep
}
r.LinuxExecStepCo... | func flattenPatchDeploymentPatchConfigWindowsUpdateMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigWindowsUpdate {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigWindowsUpdate{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigWindowsUp... | func flattenPatchDeploymentPatchConfigPostStepLinuxExecStepConfigInterpreterEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfigInterpreterEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfigInterpre... | func expandPatchDeploymentPatchConfigPostStepSlice(c *Client, f []PatchDeploymentPatchConfigPostStep) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConfigPostStep(c, &item)
if err != nil {
... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConf... | func flattenPatchDeploymentPatchConfigYumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigYum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigYum{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigYum{}
}
items := make(map[string]Pat... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject{}
}
if len(a) == 0 {
return... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchC... | func flattenPatchDeploymentPatchConfigMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfig{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfig{}
}
items := make(map[string]PatchDeployment... | func flattenDeliveryPipelineSerialPipelineStagesMap(c *Client, i interface{}, res *DeliveryPipeline) map[string]DeliveryPipelineSerialPipelineStages {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]DeliveryPipelineSerialPipelineStages{}
}
if len(a) == 0 {
return map[string]DeliveryPipelineSeria... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectSlice(c *Client, f []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchD... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObjectSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject{}
}
if len(a) == 0 {
ret... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigMap(c *Client, f map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfig) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentPa... | func flattenPatchDeploymentInstanceFilterMap(c *Client, i interface{}) map[string]PatchDeploymentInstanceFilter {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentInstanceFilter{}
}
if len(a) == 0 {
return map[string]PatchDeploymentInstanceFilter{}
}
items := make(map[string]Pat... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObjectMap(c *Client, f map[string]PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expan... | func flattenPatchDeploymentPatchConfigPostStep(c *Client, i interface{}) *PatchDeploymentPatchConfigPostStep {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &PatchDeploymentPatchConfigPostStep{}
if dcl.IsEmptyValueIndirect(i) {
return EmptyPatchDeploymentPatchConfigPostStep
}
r.LinuxExecSt... | func flattenDashboardTabbedLayoutTabsRowLayoutMap(c *Client, i interface{}) map[string]DashboardTabbedLayoutTabsRowLayout {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]DashboardTabbedLayoutTabsRowLayout{}
}
if len(a) == 0 {
return map[string]DashboardTabbedLayoutTabsRowLayout{}
}
items :=... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepLinuxExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepLinuxExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigPreS... | func expandPatchDeploymentRolloutMap(c *Client, f map[string]PatchDeploymentRollout) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentRollout(c, &item)
if err != nil {
return nil, err
}
if i ... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObjectSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject{}
}
if len(a) == 0 {
return []Pat... | func flattenVersionEntrypointMap(c *Client, i interface{}) map[string]VersionEntrypoint {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionEntrypoint{}
}
if len(a) == 0 {
return map[string]VersionEntrypoint{}
}
items := make(map[string]VersionEntrypoint)
for k, item := range a {
item... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigMap(c *Client, f map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfig) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeployment... | func flattenVersionInstanceSpecPortsMap(c *Client, i interface{}) map[string]VersionInstanceSpecPorts {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionInstanceSpecPorts{}
}
if len(a) == 0 {
return map[string]VersionInstanceSpecPorts{}
}
items := make(map[string]VersionInstanceSpecPort... | func flattenPatchDeploymentRolloutDisruptionBudgetMap(c *Client, i interface{}) map[string]PatchDeploymentRolloutDisruptionBudget {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRolloutDisruptionBudget{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRolloutDisruptionBudget... | func flattenPatchDeploymentPatchConfigAptTypeEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigAptTypeEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigAptTypeEnum{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigAptTypeEnum{}
... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObjectSlice(c *Client, f []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatc... | func flattenPatchDeploymentOneTimeScheduleMap(c *Client, i interface{}) map[string]PatchDeploymentOneTimeSchedule {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentOneTimeSchedule{}
}
if len(a) == 0 {
return map[string]PatchDeploymentOneTimeSchedule{}
}
items := make(map[string... | func flattenVersionInstanceSpecSandboxesMap(c *Client, i interface{}) map[string]VersionInstanceSpecSandboxes {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionInstanceSpecSandboxes{}
}
if len(a) == 0 {
return map[string]VersionInstanceSpecSandboxes{}
}
items := make(map[string]Version... | func flattenLogMetricMetricDescriptorMetadataIngestDelayMap(c *Client, i interface{}) map[string]LogMetricMetricDescriptorMetadataIngestDelay {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]LogMetricMetricDescriptorMetadataIngestDelay{}
}
if len(a) == 0 {
return map[string]LogMetricMetricDescr... | func flattenVersionJobScalingMap(c *Client, i interface{}) map[string]VersionJobScaling {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionJobScaling{}
}
if len(a) == 0 {
return map[string]VersionJobScaling{}
}
items := make(map[string]VersionJobScaling)
for k, item := range a {
item... | func flattenPatchDeploymentPatchConfigPostStepLinuxExecStepConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepLinuxExecStepConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepLinuxExecStepConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigP... | func flattenPatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObjectSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObject {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepLinuxExecStepConfigGcsObject{}
}
if len(a) == 0 {
return []... | func flattenPatchDeploymentPatchConfigWindowsUpdateClassificationsEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigWindowsUpdateClassificationsEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigWindowsUpdateClassificationsEnum{}
}
if len(a) == 0 ... | func expandPatchDeploymentPatchConfigPreStepWindowsExecStepConfigSlice(c *Client, f []PatchDeploymentPatchConfigPreStepWindowsExecStepConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchConf... | func flattenVersionHealthCheckMap(c *Client, i interface{}) map[string]VersionHealthCheck {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionHealthCheck{}
}
if len(a) == 0 {
return map[string]VersionHealthCheck{}
}
items := make(map[string]VersionHealthCheck)
for k, item := range a {
... | func flattenDashboardTabbedLayoutTabsGridLayoutMap(c *Client, i interface{}) map[string]DashboardTabbedLayoutTabsGridLayout {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]DashboardTabbedLayoutTabsGridLayout{}
}
if len(a) == 0 {
return map[string]DashboardTabbedLayoutTabsGridLayout{}
}
item... | func flattenPatchDeploymentPatchConfigZypperMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigZypper {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigZypper{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigZypper{}
}
items := make(ma... | func flattenPatchDeploymentInstanceFilterGroupLabelsMap(c *Client, i interface{}) map[string]PatchDeploymentInstanceFilterGroupLabels {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentInstanceFilterGroupLabels{}
}
if len(a) == 0 {
return map[string]PatchDeploymentInstanceFilterGro... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObjectMap(c *Client, f map[string]PatchDeploymentPatchConfigPostStepWindowsExecStepConfigGcsObject) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := exp... | func stepFields() map[string]*schema.Schema {
s := map[string]*schema.Schema{
"input_value": {
Type: schema.TypeFloat,
Required: true,
ForceNew: true,
},
"input_unit": {
Type: schema.TypeString,
Required: true,
ForceNew: true,
},
"output_value": {
Type: schema.TypeFloat,
C... | func flattenPatchDeploymentPatchConfigAptSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigApt {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigApt{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigApt{}
}
items := make([]PatchDeploymentPatchConfigApt, 0, len(a))
for... | func flattenVersionLivenessCheckMap(c *Client, i interface{}) map[string]VersionLivenessCheck {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionLivenessCheck{}
}
if len(a) == 0 {
return map[string]VersionLivenessCheck{}
}
items := make(map[string]VersionLivenessCheck)
for k, item := r... | func flattenVersionAutomaticScalingRequestUtilizationMap(c *Client, i interface{}) map[string]VersionAutomaticScalingRequestUtilization {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionAutomaticScalingRequestUtilization{}
}
if len(a) == 0 {
return map[string]VersionAutomaticScalingReques... | func flattenItemPreprocessors(item zabbix.Item) []interface{} {
val := make([]interface{}, len(item.Preprocessors))
for i := 0; i < len(item.Preprocessors); i++ {
val[i] = map[string]interface{}{
//"id": host.Interfaces[i].InterfaceID,
"type": item.Preprocessors[i].Type,
"error_handler": ... | func flattenPatchDeploymentRecurringScheduleMonthlyMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringScheduleMonthly {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringScheduleMonthly{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRecurringScheduleMon... | func flattenPatchDeploymentPatchConfigGooMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigGoo {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigGoo{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfigGoo{}
}
items := make(map[string]Pat... | func flattenPatchDeploymentRecurringScheduleMonthlyWeekDayOfMonthMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonth {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringScheduleMonthlyWeekDayOfMonth{}
}
if len(a) == 0 {
return map[... | func flattenDashboardTabbedLayoutTabsMap(c *Client, i interface{}) map[string]DashboardTabbedLayoutTabs {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]DashboardTabbedLayoutTabs{}
}
if len(a) == 0 {
return map[string]DashboardTabbedLayoutTabs{}
}
items := make(map[string]DashboardTabbedLayo... | func flattenPatchDeploymentPatchConfigRebootConfigEnumMap(c *Client, i interface{}) map[string]PatchDeploymentPatchConfigRebootConfigEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentPatchConfigRebootConfigEnum{}
}
if len(a) == 0 {
return map[string]PatchDeploymentPatchConfig... | func expandPatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObjectSlice(c *Client, f []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeplo... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepWindowsExecStepConfigInterpreterEnum{}
}
if len(... | func flattenVersionInstanceSpecSandboxesContainersMap(c *Client, i interface{}) map[string]VersionInstanceSpecSandboxesContainers {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionInstanceSpecSandboxesContainers{}
}
if len(a) == 0 {
return map[string]VersionInstanceSpecSandboxesContainers... | func expandPatchDeploymentPatchConfigPreStepLinuxExecStepConfigMap(c *Client, f map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfig) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentPatchC... | func flattenPatchDeploymentRecurringScheduleTimeOfDayMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringScheduleTimeOfDay {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringScheduleTimeOfDay{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRecurringSched... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfig(c *Client, i interface{}) *PatchDeploymentPatchConfigPreStepWindowsExecStepConfig {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &PatchDeploymentPatchConfigPreStepWindowsExecStepConfig{}
if dcl.IsEmptyValueIndirect(i) {
retu... | func flattenLogMetricMetricDescriptorMetadataSamplePeriodMap(c *Client, i interface{}) map[string]LogMetricMetricDescriptorMetadataSamplePeriod {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]LogMetricMetricDescriptorMetadataSamplePeriod{}
}
if len(a) == 0 {
return map[string]LogMetricMetricDe... | func expandPatchDeploymentPatchConfigPostStepWindowsExecStepConfigSlice(c *Client, f []PatchDeploymentPatchConfigPostStepWindowsExecStepConfig) ([]map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := []map[string]interface{}{}
for _, item := range f {
i, err := expandPatchDeploymentPatchCo... | func flattenVersionDeploymentMap(c *Client, i interface{}) map[string]VersionDeployment {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionDeployment{}
}
if len(a) == 0 {
return map[string]VersionDeployment{}
}
items := make(map[string]VersionDeployment)
for k, item := range a {
item... | func flattenPatchDeploymentPatchConfigWindowsUpdateSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigWindowsUpdate {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigWindowsUpdate{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfigWindowsUpdate{}
}
items := make([]PatchD... | func expandPatchDeploymentPatchConfigPostStepLinuxExecStepConfigMap(c *Client, f map[string]PatchDeploymentPatchConfigPostStepLinuxExecStepConfig) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPatchDeploymentPatc... | func flattenPatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject(c *Client, i interface{}) *PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject {
m, ok := i.(map[string]interface{})
if !ok {
return nil
}
r := &PatchDeploymentPatchConfigPreStepWindowsExecStepConfigGcsObject{}
if dcl.IsEmp... | func flattenDashboardTabbedLayoutMap(c *Client, i interface{}) map[string]DashboardTabbedLayout {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]DashboardTabbedLayout{}
}
if len(a) == 0 {
return map[string]DashboardTabbedLayout{}
}
items := make(map[string]DashboardTabbedLayout)
for k, item... | func flattenPatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPostStepWindowsExecStepConfigInterpreterEnum{}
}
if l... | func expandPatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObjectMap(c *Client, f map[string]PatchDeploymentPatchConfigPreStepLinuxExecStepConfigGcsObject) (map[string]interface{}, error) {
if f == nil {
return nil, nil
}
items := make(map[string]interface{})
for k, item := range f {
i, err := expandPat... | func flattenPatchDeploymentPatchConfigSlice(c *Client, i interface{}) []PatchDeploymentPatchConfig {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfig{}
}
if len(a) == 0 {
return []PatchDeploymentPatchConfig{}
}
items := make([]PatchDeploymentPatchConfig, 0, len(a))
for _, item := ran... | func flattenVersionInstanceSpecMap(c *Client, i interface{}) map[string]VersionInstanceSpec {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionInstanceSpec{}
}
if len(a) == 0 {
return map[string]VersionInstanceSpec{}
}
items := make(map[string]VersionInstanceSpec)
for k, item := range ... | func flattenVersionPoolScalingMap(c *Client, i interface{}) map[string]VersionPoolScaling {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionPoolScaling{}
}
if len(a) == 0 {
return map[string]VersionPoolScaling{}
}
items := make(map[string]VersionPoolScaling)
for k, item := range a {
... | func ConvertSteps(steps []*pbc.Step, indent int) []string {
lines := []string{}
for _, step := range steps {
commonLines := []string{
fmt.Sprintf("%s stepID: %d", strings.Repeat(" ", indent), step.StepID),
fmt.Sprintf("%s stepOrder: %d", strings.Repeat(" ", indent), step.StepOrder),
fmt.Sprintf("%s ... | func flattenAutoscalerStatusDetailsMap(c *Client, i interface{}) map[string]AutoscalerStatusDetails {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]AutoscalerStatusDetails{}
}
if len(a) == 0 {
return map[string]AutoscalerStatusDetails{}
}
items := make(map[string]AutoscalerStatusDetails)
f... | func flattenPatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnumSlice(c *Client, i interface{}) []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnum {
a, ok := i.([]interface{})
if !ok {
return []PatchDeploymentPatchConfigPreStepLinuxExecStepConfigInterpreterEnum{}
}
if len(a) == ... | func flattenVersionAutomaticScalingCpuUtilizationMap(c *Client, i interface{}) map[string]VersionAutomaticScalingCpuUtilization {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionAutomaticScalingCpuUtilization{}
}
if len(a) == 0 {
return map[string]VersionAutomaticScalingCpuUtilization{}
... | func flattenPatchDeploymentRecurringScheduleWeeklyMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringScheduleWeekly {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringScheduleWeekly{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRecurringScheduleWeekly... | func flattenVersionHandlersApiEndpointMap(c *Client, i interface{}) map[string]VersionHandlersApiEndpoint {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionHandlersApiEndpoint{}
}
if len(a) == 0 {
return map[string]VersionHandlersApiEndpoint{}
}
items := make(map[string]VersionHandlers... | func flattenInstanceManagementConfigMap(c *Client, i interface{}, res *Instance) map[string]InstanceManagementConfig {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]InstanceManagementConfig{}
}
if len(a) == 0 {
return map[string]InstanceManagementConfig{}
}
items := make(map[string]Instance... | func (woc *wfOperationCtx) expandStep(step wfv1.WorkflowStep) ([]wfv1.WorkflowStep, error) {
stepBytes, err := json.Marshal(step)
if err != nil {
return nil, errors.InternalWrapError(err)
}
fstTmpl := fasttemplate.New(string(stepBytes), "{{", "}}")
expandedStep := make([]wfv1.WorkflowStep, 0)
var items []wfv1.I... | func flattenPatchDeploymentRecurringScheduleMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringSchedule {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringSchedule{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRecurringSchedule{}
}
items := make(ma... | func flattenPatchDeploymentRolloutModeEnumMap(c *Client, i interface{}) map[string]PatchDeploymentRolloutModeEnum {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRolloutModeEnum{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRolloutModeEnum{}
}
items := make(map[string... | func flattenPatchDeploymentRecurringScheduleTimeZoneMap(c *Client, i interface{}) map[string]PatchDeploymentRecurringScheduleTimeZone {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]PatchDeploymentRecurringScheduleTimeZone{}
}
if len(a) == 0 {
return map[string]PatchDeploymentRecurringSchedule... | func flattenVersionHandlersScriptMap(c *Client, i interface{}) map[string]VersionHandlersScript {
a, ok := i.(map[string]interface{})
if !ok {
return map[string]VersionHandlersScript{}
}
if len(a) == 0 {
return map[string]VersionHandlersScript{}
}
items := make(map[string]VersionHandlersScript)
for k, item... | [
"0.6765291",
"0.6634858",
"0.6297781",
"0.6244933",
"0.6188869",
"0.61728126",
"0.6147888",
"0.6132687",
"0.61211866",
"0.60493267",
"0.60373133",
"0.5997912",
"0.5941682",
"0.5928907",
"0.59228545",
"0.5913746",
"0.58554214",
"0.5854204",
"0.58332294",
"0.5825133",
"0.581725... |
Handle is the handler for the AuthAPI module | func (authAPI *AuthAPI) Handle(router *http.ServeMux, database *sql.DB) {
authAPI.database = database
authAPI.router = mux.NewRouter()
authAPI.handleCredentialsLogin()
router.Handle(AuthAPIURLStub, authAPI.router)
router.Handle(AuthAPIExtURLStub, authAPI.router)
} | func Handle(
auth Authorizer,
fn func(http.ResponseWriter, *http.Request),
) http.Handler {
return http.HandlerFunc(HandlerFunc(auth, fn))
} | func Handle(ctx context.Context, w http.ResponseWriter, r *http.Request, a *App) {
authInfo := auth.FromContext(ctx)
authInfo.UpdateHeaders(w.Header())
if authInfo == nil || !authInfo.Authenticated {
http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
return
}
a.Handler.ServeHTTP(... | func (sh *signHandler) Handle(w http.ResponseWriter, r *http.Request) error {
log.Debugf("Received request for endpoint %s", sh.endpoint)
err := sh.handle(w, r)
if err != nil {
log.Errorf("Enrollment failure: %s", err)
}
return err
} | func (h *getHandler) Handle(w http.ResponseWriter, r *http.Request, ctx context.Context) error {
flow, err := h.logins.GetLoginFlowFrom(r)
if err != nil {
return err
}
return httputils.WriteJson(w, flow, http.StatusFound)
} | func (h *tokenHandler) Handle(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
var req = &models.TokenRequest{}
_ = json.NewDecoder(r.Body).Decode(req)
if req.GrantType == "client_credentials" {
res, err := h.handleClientCredentials(req)
if err != nil {
logger.Wa... | func (a *AuthFilter) HandleAuth(w http.ResponseWriter, r *http.Request) {
_, err :=CheckToken(r)
if err != nil {
writeError(w, &ctrlError{httpCode:401, errorMsg:"#NotAuthenticated"})
return
} else {
a.HandleBusiness(w, r)
}
} | func (c LoginController) Handle(r *http.Request, response *util.Response) (resp *util.Response, e error) {
email, password := getValues(r)
validationError := validate(email, password)
if validationError != nil {
return response.WithApiError(validationError.Error(), 400, config.InvalidFormParameters), nil
}
us... | func HandleAuth(w http.ResponseWriter, r *http.Request) {
handleCORS(w, r)
if r.Method != http.MethodPost {
errorResponse(w, http.StatusMethodNotAllowed, ErrBadMethod)
return
}
token, err := signInUser(r)
if err != nil {
errorResponse(w, http.StatusBadRequest, err)
return
}
err = json.NewEncoder(w).En... | func (authHandler authHandler) Handle() {
fmt.Println("========= ENTERING AUTH PHASE =========")
authHandler.handleAuthentication() //HC + key
authHandler.handleQueue() // Af + pos | total | useless data
isConnected := authHandler.handleAuthenticationResult() //Ad | Alef...
if isConnected == true {
authHandl... | func (m *Authentication) Handle(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if isAllowedPath(r) {
h.ServeHTTP(w, r)
return
}
token, err := getAccessToken(r)
if err != nil {
m.RespondError(w, err, http.StatusUnauthorized)
return
}
jwt, ... | func handleAuthProvider(res http.ResponseWriter, req *http.Request) {
gothic.BeginAuthHandler(res, req)
} | func (h Handler) Handle(r *http.Request) (body interface{}, err error, status int) {
user, err := h.AuthenticatedUser(r)
if err != nil {
return nil, err, http.StatusUnauthorized
}
for _, p := range h.Providers {
switch r.URL.Path {
case p.Paths.Consent:
return h.handleConsent(r, user, p)
case p.Paths.Co... | func Handle(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
url := "https://julestruong.eu.auth0.com/userinfo"
tokenString := r.Header.Get("Authorization")
if tokenString == "" {
log.Printf("No token string")
http.Error(w, "No token string", http.... | func (client *dofusClient) handle() {
auth_phase.NewAuthHandler(client.serverSocket, client.cfg).Handle()
fmt.Println("Ending auth phase")
} | func (m *AuthzMiddleware) Handle(ctx dotweb.Context) error {
if !CheckPermission(m.Enforcer, ctx.Request().Request) {
ctx.Response().SetStatusCode(403)
return nil
}
m.Next(ctx)
return nil
} | func (h *Handler) serveAuthenticate(w http.ResponseWriter, r *http.Request) {} | func HandleAuth(ctx context.Context, req events.APIGatewayCustomAuthorizerRequest) (events.APIGatewayCustomAuthorizerResponse, error) {
// token := strings.ToLower(evt.AuthorizationToken)
// validate the incoming token
// and produce the principal user identifier associated with the token
// this could be accompli... | func (r *Router) Handle(uri string, handlers ...RouterConfigParam) {
uri = r.prefix + uri
rc := &routerConfig{auth: true, isExecution: false, needAdmin: false}
mapRouterConfigs[uri] = rc
for _, h := range handlers {
h(rc)
}
f := func(w http.ResponseWriter, req *http.Request) {
// Close indicates to close t... | func (r *APIRouter) Handle(method, path string, handler ReturnHandlerFunc, auth bool) {
action := runtime.FuncForPC(reflect.ValueOf(handler).Pointer()).Name()
if auth {
handler = withAuth(r.sessionStore, handler)
}
r.mux.Methods(method).Path(path).Handler(
withLogging(action, r.output,
withJSONResponse(
... | func (s *Server) handlerAPIAuthenticate(w http.ResponseWriter, r *http.Request) {
if !s.limiter.Check("authenticate", w, r) {
return
}
urlParams := mux.Vars(r)
uname := urlParams["username"]
ipaddress := r.RemoteAddr
useragent := r.Header.Get("User-Agent")
if useragent == "" {
s.handlerAPIBadRequestError(w... | func HandleLogin(w http.ResponseWriter, r *http.Request) {
// Read the HTTP request body
body, err := ioutil.ReadAll(r.Body)
if err != nil {
api.WriteError(w, http.StatusBadRequest, err, false, nil)
return
}
defer r.Body.Close()
if len(body) < 1 {
api.WriteError(w, http.StatusBadRequest, api.ErrEmptyBody,... | func (authMiddleware *AuthMiddleware) Handle(next echo.HandlerFunc) echo.HandlerFunc {
return func(context echo.Context) error {
host := context.Request().Host
// Check first if strategy for this host exist.
// If-else-construct is confused (`return next(context)` should be at the end).
// - If you find a bett... | func Handler(w http.ResponseWriter, r *http.Request) {
// Only allow post requests
if r.Method != http.MethodPost {
http.Error(w, "{ \"error\": \"Method not allowed\" }", http.StatusMethodNotAllowed)
return
}
// Initialize your admin client
magic, err := admin.NewMagicAdmin(os.Getenv("MAGIC_SECRET"))
if err ... | func (fn LoginHandlerFunc) Handle(params LoginParams) middleware.Responder {
return fn(params)
} | func (fn AuthUserHandlerFunc) Handle(params AuthUserParams) middleware.Responder {
return fn(params)
} | func Handle(req []byte) string {
key := os.Getenv("Http_X_Api_Key") // converted via the Header: X-Api-Key
secretBytes, err := getAPISecret("secret_api_key") // You must create a secret ahead of time named `secret_api_key`
if err != nil {
log.Fatal(err)
}
secret := strings.TrimSpace(string(secretBytes))
mes... | func (s *AuthenticateHandler) Handler(ctx *gin.Context) {
// Parse body: otp
// body should be just text, not json.
body, err := ioutil.ReadAll(ctx.Request.Body)
if err != nil {
ctx.Error(errors.New("user cannot be authenticated. reason: body cannot be parsed"))
ctx.AbortWithError(http.StatusInternalServerEr... | func (a *App) Handle(pattern string, level UserLevel, handler Handler) {
a.Mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
jwt := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer"))
if jwt == "" {
cookie, _ := r.Cookie(a.Cookie)
if cookie == nil {
if leve... | func HandleLogin(w http.ResponseWriter, r *http.Request) {
client, err := helix.NewClient(&helix.Options{
ClientID: clientID,
RedirectURI: redirectURL,
})
if err != nil {
log.Println("NewClient:", err)
w.WriteHeader(http.StatusInternalServerError)
return
}
// cria state token
var tokenBytes [255]byt... | func HandleAuthenticate(t *testing.T) {
testhelper.Mux.HandleFunc("/auth/tokens", func(w http.ResponseWriter, r *http.Request) {
testhelper.TestMethod(t, r, "POST")
testhelper.TestHeader(t, r, "Content-Type", "application/json")
testhelper.TestHeader(t, r, "Accept", "application/json")
testhelper.TestHeader(t,... | func (fn PostLoginHandlerFunc) Handle(params PostLoginParams) middleware.Responder {
return fn(params)
} | func HandleLogin(env *env.Env, w http.ResponseWriter, r *http.Request) error {
p := struct {
Email string `json:"email"`
Password string `json:"password"`
}{}
if err := decodeJSON(r.Body, &p); err != nil {
return err
}
user, err := domain.Authenticate(env.DB, p.Email, p.Password)
if err != nil {
return... | func (a *Api) HandleAuthorization(w http.ResponseWriter, r *http.Request) {
var reqBody struct {
Login string `json:"login"`
Password string `json:"password"`
}
if err := json.NewDecoder(r.Body).Decode(&reqBody); err != nil {
err = fmt.Errorf("decode request body: %v", err)
logI.Print(err)
replyWithErro... | func (fn NrPassportLoginByThirdPartyHandlerFunc) Handle(params NrPassportLoginByThirdPartyParams) middleware.Responder {
return fn(params)
} | func AuthHandler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reqToken := r.Header.Get("Authorization")
splitToken := strings.Split(reqToken, "Bearer ")
// check if there is a Bearer token (token will be at index 1)
if len(splitToken) < 2 {
http.Erro... | func (oa *OneAccount) Auth(next http.Handler) http.Handler {
hfc := func(w http.ResponseWriter, r *http.Request) {
ctx := r.Context()
if oa == nil || oa.Engine == nil {
oa.error(ctx, fmt.Errorf("engine is not provided or the library is not initialised"))
next.ServeHTTP(w, r)
return
}
if oa.CallbackURL... | func (h *HttpAuthHandler) Auth() http.Handler {
return http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
if req.Method != "POST" {
utils.JsonResponse(res, "Invalid Method", http.StatusMethodNotAllowed)
return
}
grantTypes, ok := req.URL.Query()["grant_type"]
if !ok || len(grantTypes)... | func AuthHandler(w http.ResponseWriter, r *http.Request) {
var tokenQuery tokenQuery
body, err := in.JSON(r, &tokenQuery)
if err != nil {
out.JSON(w, 400, err)
return
}
authQueryResult := core.ValidateJSON("auth", "authQuery", string(body))
if !authQueryResult.Valid {
out.JSON(w, 422, authQueryResult.Erro... | func AuthHandler(context *gin.Context) {
util.JWTAuth(secret)(context)
} | func (fn OauthRedirectHandlerFunc) Handle(params OauthRedirectParams) middleware.Responder {
return fn(params)
} | func (p *Plugin) handleAuthRequired(handleFunc func(w http.ResponseWriter, r *http.Request)) func(w http.ResponseWriter, r *http.Request) {
return func(w http.ResponseWriter, r *http.Request) {
if status, err := verifyHTTPSecret(p.configuration.Secret, r.FormValue("secret")); err != nil {
p.API.LogError(fmt.Sprin... | func (fn PostUserLoginHandlerFunc) Handle(params PostUserLoginParams) middleware.Responder {
return fn(params)
} | func AuthHandler(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if pubkey == nil {
log.Error("Secure handler was called but public ca file is missing")
http.Error(w, "This handler is unavailable due to a configuration error", http.StatusInternalServerErro... | func Handle(mux *http.ServeMux, db *sql.DB) {
handleFuncAuthenticated("/report", verificationreport.Export, db)
} | func (r *RegistryAPI) handleGetUser(w http.ResponseWriter, req *http.Request) {
user, pass, valid := authHeader(req)
if !valid {
log.Println("Authheader not valid")
w.WriteHeader(http.StatusUnauthorized)
return
}
if !r.registry.Authenticator().Authenticate(user, pass) {
log.Println("Authentication failed")
... | func (fn PostAuthorizeHandlerFunc) Handle(params PostAuthorizeParams) middleware.Responder {
return fn(params)
} | func (h *UserHandler) Handle(rw http.ResponseWriter, r *http.Request) {
ih.Route(rw, r, ih.MethodHandlers{
http.MethodPost: h.CreateUser,
http.MethodGet: h.GetMyProfile,
http.MethodDelete: h.DeleteUser,
http.MethodPut: h.UpdateProfile,
http.MethodOptions: nil})
} | func HandleAuth(workers core.WorkerRegistry, config *config.Config, ws *ws.App) http.HandlerFunc {
type resp struct {
Auth string `json:"auth"`
}
return func(w http.ResponseWriter, r *http.Request) {
claims := middlewares.WorkerClaimsFromCtx(r.Context())
_, port, err := net.SplitHostPort(claims.Addr)
if err... | func (e Endpoint) Handle(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
req := WrapHttpRouterReq(w, r, ps)
e.Serve(context.Background(), req)
} | func AuthHandler(handler AuthorisedRequestHandler) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, params httprouter.Params) {
// Measure time spent executing shit
start := time.Now()
// Authorize request
err := authorize(r)
if err != nil {
// Logs [source IP] [request method] [re... | func AuthHandler(w http.ResponseWriter, r *http.Request,
next http.HandlerFunc, vKey *rsa.PublicKey) {
token, err := request.ParseFromRequest(r, request.AuthorizationHeaderExtractor,
func(token *jwt.Token) (interface{}, error) {
return vKey, nil
})
if err == nil {
if token.Valid {
next(w, r)
} else {
... | func (userApi *UserAPI) Handle(router *http.ServeMux) {
userApi.router = mux.NewRouter()
userApi.handleGetUserByUUID(userApi.router)
userApi.handleQueryUsers(userApi.router)
userApi.handleCreateUser(userApi.router)
userApi.handleDeleteUserByUUID(userApi.router)
userApi.handleUpdateUser(userApi.router)
router.Han... | func AuthHandler(h web.SimpleHandler, ctx *web.Context) error {
ctx.User = "Passed from AuthHandler"
fmt.Println(ctx.Request.Header)
return nil
} | func (a *Auth) Handler(next http.Handler) http.Handler {
return a.cors.Handler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
authString, err := request.AuthorizationHeaderExtractor.ExtractToken(r)
if err != nil {
next.ServeHTTP(w, r)
return
}
ctx := context.WithValue(r.Context(), authCt... | func (h *Handler) Handle(req string) {
log.Println("Request: " + req)
err := h.postToApi(req)
if err != nil {
log.Println(err)
}
} | func APIAuthHandler(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
user := auth.GetUser(r.Context())
if user == nil {
http.Error(w, "Bad credentials", http.StatusUnauthorized)
return
}
next.ServeHTTP(w, r)
})
} | func (fn PutUserLoginHandlerFunc) Handle(params PutUserLoginParams, principal interface{}) middleware.Responder {
return fn(params, principal)
} | func (h *Handler) HandleAuthTest(w http.ResponseWriter, r *http.Request) {
if err := r.ParseForm(); err != nil {
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
if !h.validateToken(r) {
http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
return
}
... | func (hf HandlerFunc) Handle(ctx *Context) error { return hf(ctx) } | func authHandler(w http.ResponseWriter, r *http.Request) {
// pull the auth details from the request
user, pass, ok := r.BasicAuth()
if ok == true {
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
host = ""
}
r := &AuthEvent{
Time: fmt.Sprintf("%d", time.Now().Unix()),
AuthT... | func (a *Authenticate) Handler() http.Handler {
r := httputil.NewRouter()
r.Use(middleware.SetHeaders(CSPHeaders))
r.Use(csrf.Protect(
a.cookieSecret,
csrf.Path("/"),
csrf.Domain(a.cookieDomain),
csrf.UnsafePaths([]string{"/oauth2/callback"}), // enforce CSRF on "safe" handler
csrf.FormValueName("state"), ... | func (m *AuthMethod) handler(ctx *router.Context, cb handler) {
cfg, err := m.checkConfigured(ctx.Context)
if err == nil {
var discovery *openid.DiscoveryDoc
discovery, err = cfg.discoveryDoc(ctx.Context)
if err == nil {
err = cb(ctx.Context, ctx.Request, ctx.Writer, cfg, discovery)
}
}
if err != nil {
... | func authHandler(w http.ResponseWriter, r *http.Request){
//validate token
token, err := request.ParseFromRequestWithClaims(r, request.OAuth2Extractor, &AppClaims{}, func(token *jwt.Token)(interface{}, error){
//since we use only 1 private key to sign tokens and only use its public counter part to verify
return ... | func Auth(next buffalo.Handler) buffalo.Handler {
return func(c buffalo.Context) error {
header := c.Request().Header
var err error
if header.Get("appid") == "app-id goes here" && header.Get("appsecret") == "app-secret goes here" {
err = next(c)
} else {
err = errors.New("invalid credentials")
}
// d... | func (authz *Authz) Handler(ctx *middlewares.AutheliaCtx) {
var (
object authorization.Object
autheliaURL *url.URL
provider *session.Session
err error
)
if object, err = authz.handleGetObject(ctx); err != nil {
ctx.Logger.WithError(err).Error("Error getting Target URL and Request Method")
... | func (fn CreateAuthorizationHandlerFunc) Handle(params CreateAuthorizationParams) middleware.Responder {
return fn(params)
} | func (h *Handlers) AuthHandler(w http.ResponseWriter, r *http.Request) {
state, err := uuid.NewV4()
if err != nil {
log.Fatal("Could not generate uuid")
w.WriteHeader(http.StatusInternalServerError)
w.Header().Add("content-type", "text/plain")
io.WriteString(w, "Could not generate state for oauth process")
... | func (s myApi) Auth(h http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
username, _, _ := r.BasicAuth()
if username != "admin" {
http.Error(w, "Unauthorized", http.StatusUnauthorized)
return
}
h(w, r)
// you can also run code after wrapped handler here
// you... | func HandleAuthorize(w http.ResponseWriter, r *http.Request) {
//Get the Google URL which shows the Authentication page to the user
url := GoogOauthCfg.AuthCodeURL("")
//redirect user to that page
http.Redirect(w, r, url, http.StatusFound)
} | func (p PluginFunc) Handle(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {
p(w, r, next)
} | func authHandler(h HandlerFunc, jw *JsonResponseWriter, r *http.Request) {
if performAuth(r) {
h(jw, r)
jw.t_end = time.Now()
log.Printf("%s|%s|%s|%db|%d|%dus", r.Header.Get("X-Forwarded-For"), r.Method, r.RequestURI, jw.Size(), jw.Status(), jw.t_end.Sub(jw.t_start)/1000)
} else {
jw.WriteHeader(401)
jw.Wr... | func (h HandlerFunc) Handle(ctx *Context, res *http.Response, err error) {
h(ctx, res, err)
} | func AuthHandler(w http.ResponseWriter, r *http.Request, conn connectors.Clients) {
var response *schema.Response
token := r.Header.Get(strings.ToLower("Authorization"))
conn.Trace("AuthHandler header : %s", token)
if token == "" || !strings.Contains(token, "Bearer") || len(token) < 20 {
w.WriteHeader(http.Stat... | func Handle(ectx *ebert.Context, r *http.Request, args *struct{ path string }) (interface{}, error) {
user, err := ebert.UserFromRequest(r)
if err != nil {
return nil, ebert.NewError(
fmt.Errorf("file:get-user: %w", err),
"Couldn't determine user's identity",
http.StatusUnauthorized,
)
}
ctx, err := ec... | func CustomHandle(env *models.Env, handlers ...Handler) http.Handler {
statusCode := ""
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
responseDetails := &customhttpresponse.ResponseDetails{}
// Retrieve AuthMiddleware method name for response details
action := strings.Split(runtime.... | func (fn TokenHandlerFunc) Handle(params TokenParams) middleware.Responder {
return fn(params)
} | func (server *Server) handleAuth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if server.authZ(r) && server.fetchRefreshToken() {
next.ServeHTTP(w, r)
return
}
http.Error(w, "user not authorized to access this resource", 403)
})
} | func (RefreshTokenMiddleware) Handle(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var a auth.JWTAuth
conf := kernel.RetrieveAppConf()
a.RefreshToken(w, conf.Key)
next.ServeHTTP(w, r)
})
} | func (fn GetLinkedAccountsHandlerFunc) Handle(params GetLinkedAccountsParams, principal interface{}) middleware.Responder {
return fn(params, principal)
} | func Handle(w http.ResponseWriter, r *http.Request) {
redirect := r.FormValue("redirect") != ""
if redirect {
http.Redirect(w, r, r.FormValue("redirect"), http.StatusTemporaryRedirect)
return
}
for k, v := range r.Header {
fmt.Printf("k: %s, v: %s\n", k, v)
}
if isValidSignature(r, "ffde76180518da0a7b31b8... | func Handle(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
switch path {
case "/api/v1/package/register":
switch method {
case "POST":
packageRegisterPOST(w, r)
default:
Error405(w, r)
}
default:
Error404(w, r)
}
} | func AuthHandler(ctx context.Context, log *logrus.Logger, jwtClient spire.JWTSVID, c config.Config, w http.ResponseWriter, r *http.Request) error {
modeHeader := r.Header.Get(JWTModeHeader)
method := r.Method
path := r.URL.Path
log.WithFields(logrus.Fields{
"method": method,
"path": path,
"mode_h... | func handleAuth(res http.ResponseWriter, req *http.Request) {
url := fmt.Sprintf("%s/auth/%s", host, req.FormValue("provider"))
fmt.Printf("redirect to %s\n", url)
http.Redirect(res, req, url, http.StatusTemporaryRedirect)
} | func (fn GetLoggedInUserInfoHandlerFunc) Handle(params GetLoggedInUserInfoParams, principal *models.JWTClaimBody) middleware.Responder {
return fn(params, principal)
} | func (r *router) Handle(method, pattern string, handler http.Handler) {
r.HandlePolicy(method, pattern, anyPolicy, handler)
} | func (d *Dispatcher) Handle(state, code string) (*structs.User, *oauth2.Token, error) {
d.mu.RLock()
g, ok := d.g[state]
d.mu.RUnlock()
if !ok {
return nil, nil, fmt.Errorf("invalid CSRF token: %s", state)
}
err := g.Handle(state, code)
d.mu.Lock()
delete(d.g, state)
d.mu.Unlock()
return &g.User, g.Token, e... | func HandleLogin(c echo.Context) error {
in := &loginUser{}
if err := c.Bind(in); err != nil {
return c.String(http.StatusBadRequest, err.Error())
}
var (
user *model.User
err error
)
switch c.QueryParam("by") {
case "sms":
user, err = store.GetUserPhone(c, in.Phone)
default:
user, err = store.GetUse... | func HandleMe(rw http.ResponseWriter, req *http.Request) {
ctx := engine.GetContext(req)
user, ok := ctx.Value("user").(*datastore.User)
if !ok {
engine.JSON(rw, errors.New("Not Authenticated"), http.StatusUnauthorized)
return
}
engine.JSON(rw, user, http.StatusOK)
} | func (ur URLVerificationRequestHandlerFunctor) Handle(ac appcontext.AppContext, data EventCallbackData) *Response {
log.InfoWithContext(ac, "URLVerification called", data.Challenge)
if data.Challenge == "" {
return newErrorHandlerResponse(ac, "invalid challenge", "empty")
}
// URL verification process just dep... | func handleAuthCallback(ctx context.Context, a *oidc.Authenticator) func(w http.ResponseWriter, r *http.Request) (interface{}, error) {
return func(w http.ResponseWriter, r *http.Request) (interface{}, error) {
res, err := a.HandleIssuerResponse(ctx, r.URL.Query().Get("state"), r.URL.Query().Get("code"))
if err !=... | func (s *Server) authHandler(w http.ResponseWriter, r *http.Request, _ denco.Params) {
r.ParseForm()
v := r.PostForm
user := v.Get("username")
pass := v.Get("password")
err := s.storage.token.Init(user, pass)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
s.storage.AddA... | func HandleLogin(w http.ResponseWriter, r *http.Request) {
token = nil
cookie, err := r.Cookie("token")
if err == nil {
//Set the cookie expiry date to yesterday so that the browser will expire it
cookie.Expires = time.Now().AddDate(0, -1, 0)
http.SetCookie(w, cookie)
}
//create a random string for oath2 ver... | func HandleGetUser(env *env.Env, w http.ResponseWriter, r *http.Request) error {
uid, err := getQueryInt64(r, "user_id")
if err != nil {
return err
}
user, err := domain.GetUser(env.DB, uid)
if err != nil {
return serror.NewBadRequest(err, "domain.GetUser")
}
user.Password = ""
return sendJSON(w, user)
} | func Handle(c *modules.RequestContext, r *radius.Request, next modules.Middleware) (*modules.Response, error) {
logger := c.Logger.With(zap.String("module_name", "testloopback"))
// create a response with all attributes copied from request
resp := modules.Response{
Code: radius.CodeAccessAccept,
Attributes... | func (g *Gocial) Handle(state, code string) error {
// Handle the exchange code to initiate a transport.
if g.state != state {
return fmt.Errorf("Invalid state: %s", state)
}
// Check if driver is valid
if !inSlice(g.driver, complexKeys(apiMap)) {
return fmt.Errorf("Driver not valid: %s", g.driver)
}
token... | func (f ForceSecure) Handle(w http.ResponseWriter, r *vertex.Request, next vertex.HandlerFunc) (interface{}, error) {
if !r.Secure {
if !r.IsLocal() || !f.AllowLocalInsecure {
return nil, vertex.UnauthorizedError("Insecure Access Forbidden")
}
}
return next(w, r)
} | func Handle(w http.ResponseWriter, r *http.Request) {
url := os.Getenv("URL")
allowedRequester := os.Getenv("ALLOWED_REQUESTER")
token := os.Getenv("TOKEN")
user := os.Getenv("USER")
resp, err := http.Get(url)
if err != nil {
log.Println("some error when fetching data")
log.Println(r)
return
}
defer re... | func (m *Module) HandleRequest(auth *auth.Module) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
// Return if the faas module is not enabled
if !m.isEnabled() {
w.WriteHeader(http.StatusNotFound)
json.NewEncoder(w).Encode(map[string]string{"error": "This feature isn't enabled"})
... | func (r *MyRouter) Handler(method, path, featureName string, handler http.Handler) {
r.Router.Handle(method, path,
func(w http.ResponseWriter, req *http.Request, ps httprouter.Params) {
rctx := new(context.ReqContext)
switch featureName {
case "IssueToken", "ValidateToken", "RevolkToken", "IssueVerifyCode",... | func (c *MainController) HandleLogin() {
// get data
userName := c.GetString("userName")
pwd := c.GetString("pwd")
// validate data
if userName == "" || pwd == "" {
logs.Info("no data")
c.Redirect("/login", 302)
return
}
c.Redirect("/index", 302)
} | [
"0.74763393",
"0.7257803",
"0.71445155",
"0.712392",
"0.70788234",
"0.7068299",
"0.70662105",
"0.70351785",
"0.701611",
"0.6883313",
"0.68541",
"0.6851596",
"0.678339",
"0.67563397",
"0.6740777",
"0.6720019",
"0.66898257",
"0.6686924",
"0.6677875",
"0.6652124",
"0.66367924",
... |
Value returns the value reserved in the funding coin. | func (c *fundingCoin) Value() uint64 {
return c.amt
} | func (c *SimpleCoin) Value() btcutil.Amount { return c.TxValue } | func (c *swapCoin) Value() uint64 {
return c.dexAtoms
} | func (o *MutualFundHoldingsData) GetValue() float32 {
if o == nil || o.Value == nil {
var ret float32
return ret
}
return *o.Value
} | func (d *Dropper) GetValue(c types.Currency, amount float64) uint64 {
return 0
} | func (o *SLORawErrorBudgetRemaining) GetValue() float64 {
if o == nil || o.Value == nil {
var ret float64
return ret
}
return *o.Value
} | func (_DeedContract *DeedContractCaller) Value(opts *bind.CallOpts) (*big.Int, error) {
var (
ret0 = new(*big.Int)
)
out := ret0
err := _DeedContract.contract.Call(opts, out, "value")
return *ret0, err
} | func (fm *FinalModelBalance) GetValue(fbeValue *Balance) (int, error) {
fm.buffer.Shift(fm.FBEOffset())
fbeSize, err := fm.GetFields(fbeValue)
fm.buffer.Unshift(fm.FBEOffset())
return fbeSize, err
} | func (t *Trade) Value() float64 {
//using * for pointer receiver to let the method edit the value
value := float64(t.Volume) * t.Price
if t.Buy {
value = -value
}
return value
} | func (c *SimpleCoin) Value() btcutil.Amount {
return btcutil.Amount(c.txOut().Value)
} | func (m Money) Value() float64 {
return m.amount
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (m *Payment) GetValue() int64 {
if m != nil {
return m.Value
}
return 0
} | func (t *Trade) Value() float64 {
value := float64(t.Volume) * t.Price
if t.Buy {
value = -value
}
return value
} | func value(proc *exec.Process) int64 {
return int64(currentContract.Transaction.Amount)
} | func (t *Trade) Value() float64 {
value := float64(t.Volume) * t.Price
if t.IsBuy {
value = -value
}
return value
} | func (v Purity) Value() string {
sfw := "0"
if v&PuritySFW != 0 {
sfw = "1"
}
sketchy := "0"
if v&PuritySketchy != 0 {
sketchy = "1"
}
nsfw := "0"
if v&PurityNSFW != 0 {
nsfw = "1"
}
return sfw + sketchy + nsfw
} | func (self protectionEligEnum) Value() uint8 {
return self.value_13b4a0ga7ep4v
} | func (self pendingReasonEnum) Value() uint8 {
return self.value_1dimgeet1jdut
} | func (_DeedContract *DeedContractSession) Value() (*big.Int, error) {
return _DeedContract.Contract.Value(&_DeedContract.CallOpts)
} | func (c *SimpleCoin) ValueAge() int64 { return int64(c.TxValue) * c.TxNumConfs } | func (nm NullMoney) Value() (driver.Value, error) {
if !nm.Valid {
return nil, nil
}
return nm.Money.Value()
} | func (self protectionEligTypeEnum) Value() uint8 {
return self.value_r5dsloug5e5r
} | func (d NullMoney) Value() (driver.Value, error) {
if !d.Valid {
return nil, nil
}
return d.Money.Value()
} | func (co *contractObligation) value() types.Currency {
if co.hasRevision() {
return co.RevisionTransaction.FileContractRevisions[0].NewValidProofOutputs[1].Value
}
return co.OriginTransaction.FileContracts[0].ValidProofOutputs[1].Value
} | func (self reasonCodeEnum) Value() uint8 {
return self.value_1lktzexl72pk4
} | func (o *DeserializedOutput) GetValue() float64 {
return float64(o.Value) / float64(COIN)
} | func (p Pitchbend) Value() int16 {
return p.value
} | func (self CurrencyTypeEnum) Value() uint8 {
return self.value_oj4xl0vlc3ek
} | func (o *PaymentAmountRefunded) GetValue() float64 {
if o == nil {
var ret float64
return ret
}
return o.Value
} | func (c car) getValue() float32 {
return c.price
} | func (n *NegativeBignum) Value() interface{} {
return n.V
} | func (bucket *Bucket) Value() float64 {
return bucket.value
} | func (self PaymentMethodEnum) Value() uint8 {
return self.value_oqzaz3xll6qi
} | func reservedValue(o Order,
perMatchDelta func(btcutil.Amount) btcutil.Amount) btcutil.Amount {
// If this order is in a state where it cannot be matched, return 0.
if o.Details().State.Archived() {
return 0
}
// The situation where the trader needs to pay the largest amount of
// fees is when the order gets ... | func (se SumEntry) Value() float64 {
return se.value
} | func (_DeedContract *DeedContractCallerSession) Value() (*big.Int, error) {
return _DeedContract.Contract.Value(&_DeedContract.CallOpts)
} | func (self paymentModeEnum) Value() uint8 {
return self.value_1nehvd4uobtyv
} | func (d *DepositToRewardingFund) Amount() *big.Int { return d.amount } | func (m Money) Value() (driver.Value, error) {
return m.String(), nil
} | func (m Money) Value() (driver.Value, error) {
return m.String(), nil
} | func (a *Ask) ReservedValue(feeSchedule terms.FeeSchedule) btcutil.Amount {
// For an ask the clearing price will be no lower than the ask's fixed
// rate, resulting in the smallest gain for the asker.
clearingPrice := FixedRatePremium(a.FixedRate)
return reservedValue(a, func(amt btcutil.Amount) btcutil.Amount {
... | func (s stockPosition) getValue() float32 {
return s.sharePrice * s.count
} | func (node RepoNode) Value() float64 {
return float64(node.Weight) * float64(node.Priority) / 2.0
} | func (v *VBlock) BareValue() string {
return v.value
} | func (b *Bid) ReservedValue(feeSchedule terms.FeeSchedule) btcutil.Amount {
// For a bid, the final clearing price is never higher that the bid's
// fixed rate, resulting in the highest possible premium paid by the
// bidder.
clearingPrice := FixedRatePremium(b.FixedRate)
return reservedValue(b, func(amt btcutil.... | func (v Uint) Value() (driver.Value, error) {
if !v.Valid() {
return nil, nil
}
return v.uint, nil
} | func (opt Uint) Value() uint {
if opt.value != nil {
return *opt.value
} else {
return opt.initValue()
}
} | func (CountItem) Value() int64 { return 0 } | func (f *Fund) Balance() int {
return f.balance
} | func (fm *FinalModelBalance) Get() (*Balance, int, error) {
fbeResult := NewBalance()
fbeSize, err := fm.GetValue(fbeResult)
return fbeResult, fbeSize, err
} | func (v *DeviceSimulation) GetValue() int { return v.SimValue } | func (o *DeductLoyaltyPointsEffectProps) GetValue() float32 {
if o == nil {
var ret float32
return ret
}
return o.Value
} | func (e *VoidEntitlement) Value() (string, error) {
return "", nil
} | func (e *VoidEntitlement) Value() (string, error) {
return "", nil
} | func (self StateCodeEnum) Value() uint8 {
return self.value_ppcqqwdfvzyu
} | func (n *PositiveBignum) Value() interface{} {
return n.V
} | func (p *Product) Value(val VarSet) float64 {
return p.Soft(val, "soft")
} | func (obj *SpinButton) GetValue() float64 {
return obj.Candy().Guify("gtk_spin_button_get_value", obj).MustFloat64()
} | func (p PetType) Value() (driver.Value, error) { return int64(p), nil } | func (self payerStatusEnum) Value() uint8 {
return self.value_1bh0yttk0lrqv
} | func Val() uint32 {
return stk.cvr & 0x00ffffff
} | func (decaying *Decaying) Value() float64 {
decaying.Lock()
now := time.Now()
dt := now.Sub(decaying.t0).Seconds()
decaying.t0 = now
curValP := decaying.p
decaying.p = curValP * math.Pow(decaying.e, (decaying.r*dt))
pOut := decaying.p
decaying.Unlock()
return pOut
} | func (t *Thermostat) Value() float64 {
return t.value
} | func (w *Wallet) Balance() Bitcoin {
return w.balance
} | func (t *Uint) Val() uint {
return uint(atomic.LoadUint64(&t.value))
} | func (recv *SpinButton) GetValue() float64 {
retC := C.gtk_spin_button_get_value((*C.GtkSpinButton)(recv.native))
retGo := (float64)(retC)
return retGo
} | func (pNode *PowerNode) GetValue() int {
return pNode.value
} | func (s PortfolioSnapshot) GetValue() Price {
return s.value
} | func (obj *SigHashType) GetValue() int {
value := obj.Type
if (value & 0x80) != 0 {
// do nothing
} else if obj.AnyoneCanPay {
value |= 0x80
}
if (value & 0x40) != 0 {
// do nothing
} else if obj.Rangeproof {
value |= 0x40
}
return value
} | func (self StateEnum) Value() uint8 {
return self.value_ulxhrexhn5ss
} | func (c *ClaimFromRewardingFund) Amount() *big.Int { return c.amount } | func (w *Wallet) Balance() Bitcoin {
return w.value
} | func (n AccountName) Value() string {
return string(n)
} | func getControlValue(Available int) float64 {
return 0.8
// return 0.5352833626360 - (-0.01482 * float64(Available)) + (00.000200023 * math.Pow(float64(Available), 2)) - (-0.00000103 * math.Pow(float64(Available), 3))
// return (0.911 + (-0.19 * ln(float64(Available))))
} | func (NilGauge) Value() int64 { return 0 } | func (this SignalingState) Value() string {
idx := int(this)
if idx >= 0 && idx < len(rTCSignalingStateToWasmTable) {
return rTCSignalingStateToWasmTable[idx]
}
panic("unknown input value")
} | func Value(obj interface{}) Receipt {
aux, err := encoding.Encode(obj)
if err != nil {
return Receipt{ExitCode: exitcode.EncodingError}
}
return Receipt{
ExitCode: 0,
ReturnValue: aux,
GasUsed: gas.Zero,
}
} | func (g GaugeSnapshot) Value() int64 { return g.value } | func (h *HTTPChecksum) Value() string {
return h.value
} | func (self huffmanNode) Value() int {
return self.value
} | func (node *ByBlockNumNode) value() *multi_index.PeerBlockState {
return node.super.value()
} | func (n NullUint) Value() (driver.Value, error) {
if !n.Valid {
return nil, nil
}
return n.Uint, nil
} | func (NilResult) Value() int64 { return 0 } | func (o *VersionGate) Value() string {
if o != nil && o.bitmap_&256 != 0 {
return o.value
}
return ""
} | func (w *Wallet) Balance() uint64 { return w.balance } | func (w *Wallet) Balance() uint64 { return w.balance } | func (utxoWrap *UtxoWrap) Value() uint64 {
return utxoWrap.Output.Value
} | func (self pendingReasonEnum) IntValue() int {
return int(self.value_1dimgeet1jdut)
} | func (o *SLORawErrorBudgetRemaining) GetValueOk() (*float64, bool) {
if o == nil || o.Value == nil {
return nil, false
}
return o.Value, true
} | func (f FakeProof) GetValue() []byte {
return f.value
} | func (p Product) Value() float64 {
return p.Price * p.Quantity
} | func (c *SafeCounter) Value() int {
c.mux.Lock()
// Lock so only one goroutine at a time can access the map c.v.
defer c.mux.Unlock()
return c.numTransactions
} | [
"0.7082064",
"0.69452393",
"0.6746024",
"0.65587443",
"0.6554951",
"0.6537463",
"0.65222275",
"0.6482639",
"0.63960415",
"0.6376385",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0.63737124",
"0... |
RecoveryID is a byteencoded address and value of a funding coin. RecoveryID satisfies the asset.RecoveryCoin interface, so this ID will be used as input for (asset.Wallet).FundingCoins. | func (c *fundingCoin) RecoveryID() dex.Bytes {
b := make([]byte, fundingCoinIDSize)
copy(b[:20], c.addr[:])
binary.BigEndian.PutUint64(b[20:28], c.amt)
return b
} | func (c *tokenFundingCoin) RecoveryID() dex.Bytes {
b := make([]byte, tokenFundingCoinIDSize)
copy(b[:20], c.addr[:])
binary.BigEndian.PutUint64(b[20:28], c.amt)
binary.BigEndian.PutUint64(b[28:36], c.fees)
return b
} | func (o A2AProtectedManagedDiskDetailsResponseOutput) RecoveryDiskId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AProtectedManagedDiskDetailsResponse) *string { return v.RecoveryDiskId }).(pulumi.StringPtrOutput)
} | func (o ReplicationProtectedItemPropertiesResponseOutput) RecoveryFabricId() pulumi.StringPtrOutput {
return o.ApplyT(func(v ReplicationProtectedItemPropertiesResponse) *string { return v.RecoveryFabricId }).(pulumi.StringPtrOutput)
} | func GetRecovery(id string) (userUUID int, email string, err error) {
rows, err := db.Query("SELECT useruuid, email FROM recovery WHERE uuid=?", id)
if err != nil {
return
}
defer rows.Close()
rows.Next()
err = rows.Scan(&userUUID, &email)
if err != nil {
return
}
if userUUID != 0 && email != "" {
_, ... | func (o ReplicationProtectedItemPropertiesResponsePtrOutput) RecoveryFabricId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *ReplicationProtectedItemPropertiesResponse) *string {
if v == nil {
return nil
}
return v.RecoveryFabricId
}).(pulumi.StringPtrOutput)
} | func (o A2AEnableProtectionInputOutput) RecoveryContainerId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AEnableProtectionInput) *string { return v.RecoveryContainerId }).(pulumi.StringPtrOutput)
} | func (o ReplicationProtectedItemPropertiesResponseOutput) RecoveryContainerId() pulumi.StringPtrOutput {
return o.ApplyT(func(v ReplicationProtectedItemPropertiesResponse) *string { return v.RecoveryContainerId }).(pulumi.StringPtrOutput)
} | func (o NetworkMappingPropertiesResponseOutput) RecoveryNetworkId() pulumi.StringPtrOutput {
return o.ApplyT(func(v NetworkMappingPropertiesResponse) *string { return v.RecoveryNetworkId }).(pulumi.StringPtrOutput)
} | func (o CreateRecoveryPlanInputPropertiesOutput) RecoveryFabricId() pulumi.StringOutput {
return o.ApplyT(func(v CreateRecoveryPlanInputProperties) string { return v.RecoveryFabricId }).(pulumi.StringOutput)
} | func (o RecoveryPlanPropertiesResponseOutput) RecoveryFabricId() pulumi.StringPtrOutput {
return o.ApplyT(func(v RecoveryPlanPropertiesResponse) *string { return v.RecoveryFabricId }).(pulumi.StringPtrOutput)
} | func (o ReplicationProtectedItemPropertiesResponsePtrOutput) RecoveryContainerId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *ReplicationProtectedItemPropertiesResponse) *string {
if v == nil {
return nil
}
return v.RecoveryContainerId
}).(pulumi.StringPtrOutput)
} | func (o NetworkMappingPropertiesResponsePtrOutput) RecoveryNetworkId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *NetworkMappingPropertiesResponse) *string {
if v == nil {
return nil
}
return v.RecoveryNetworkId
}).(pulumi.StringPtrOutput)
} | func (o SqlPoolOutput) RecoveryDatabaseId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *SqlPool) pulumi.StringPtrOutput { return v.RecoveryDatabaseId }).(pulumi.StringPtrOutput)
} | func (c *Client) generateRecoveryPK() error {
if len(c.Keys) != 5 {
return errors.New("wrong key setup")
}
c.RecoveryPK = crypt.GetPrivateKey(c.Keys[4], uint32(c.RecoveryID)).ToECDSA()
return nil
} | func (o RecoveryPlanPropertiesResponsePtrOutput) RecoveryFabricId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *RecoveryPlanPropertiesResponse) *string {
if v == nil {
return nil
}
return v.RecoveryFabricId
}).(pulumi.StringPtrOutput)
} | func AddRecovery(id string, userUUID int, email string) (err error) {
exists, err := rowExists("SELECT id FROM recovery WHERE useruuid=?", userUUID)
if err != nil {
return
}
if exists {
_, err = db.Exec("DELETE FROM recovery WHERE useruuid=?", userUUID)
if err != nil {
return
}
}
_, err = db.Exec("INS... | func (o CreateRecoveryPlanInputPropertiesPtrOutput) RecoveryFabricId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *CreateRecoveryPlanInputProperties) *string {
if v == nil {
return nil
}
return &v.RecoveryFabricId
}).(pulumi.StringPtrOutput)
} | func (o *SubmitLoginFlowBodyWithTotp) GetRecoveryCode() string {
if o == nil || o.RecoveryCode == nil {
var ret string
return ret
}
return *o.RecoveryCode
} | func (c *fundingCoin) ID() dex.Bytes {
return []byte(c.addr.String())
} | func (o A2AReplicationDetailsResponseOutput) RecoveryFabricObjectId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AReplicationDetailsResponse) *string { return v.RecoveryFabricObjectId }).(pulumi.StringPtrOutput)
} | func GenerateRecoveryCode() string {
return recoverycode.Generate()
} | func (user *User) GenerateRecoveryCode() string {
b := make([]rune, 12)
for i := range b {
b[i] = codeLetters[rand.Intn(codeLettersLength)]
}
return string(b)
} | func (r *JobFailureRequest) ReceiptId(value string) *JobFailureRequest {
r.receiptId = &value
return r
} | func (o NetworkMappingPropertiesResponseOutput) RecoveryFabricArmId() pulumi.StringPtrOutput {
return o.ApplyT(func(v NetworkMappingPropertiesResponse) *string { return v.RecoveryFabricArmId }).(pulumi.StringPtrOutput)
} | func GetRecovery(uuid string) (userUUID, email string, err error) {
rows, err := db.Query("SELECT useruuid, email FROM recovery WHERE uuid=?", uuid)
if err != nil {
return
}
defer rows.Close()
if rows.Next() {
err = rows.Scan(&userUUID, &email)
if err != nil {
return
}
_, err = db.Exec("DELETE FROM... | func AddRecovery(userUUID, email string) (uuid string, err error) {
exists, err := rowExists("SELECT uuid FROM recovery WHERE useruuid=?", userUUID)
if err != nil {
return
}
if exists {
_, err = db.Exec("DELETE FROM recovery WHERE useruuid=?", userUUID)
if err != nil {
return
}
}
for {
uuid = uid.Ne... | func (s *Service) Recovery(c context.Context, mid int64) (err error) {
err = s.UpdateUpAccountState(c, "up_info_video", mid, 3)
if err != nil {
log.Error("s.UpdateUpAccountState(video) error(%v)", err)
return
}
err = s.UpdateUpAccountState(c, "up_info_column", mid, 3)
if err != nil {
log.Error("s.UpdateUpAcc... | func (c *tokenFundingCoin) ID() dex.Bytes {
return []byte(c.addr.String())
} | func (o ReplicationProtectedItemPropertiesResponseOutput) FailoverRecoveryPointId() pulumi.StringPtrOutput {
return o.ApplyT(func(v ReplicationProtectedItemPropertiesResponse) *string { return v.FailoverRecoveryPointId }).(pulumi.StringPtrOutput)
} | func (s *Store) Recovery(state []byte) error {
s.mutex.Lock()
defer s.mutex.Unlock()
// we need to stop all the current watchers
// recovery will clear watcherHub
s.watcher.stopWatchers()
err := json.Unmarshal(state, s)
// The only thing need to change after the recovery is the
// node with expiration time, w... | func (api *SignerAPI) EcRecover(ctx context.Context, data hexutil.Bytes, sig hexutil.Bytes) (common.Address, error) {
// Returns the address for the Account that was used to create the signature.
//
// Note, this function is compatible with eth_sign and personal_sign. As such it recovers
// the address of:
// hash... | func (r *QueuePushServerResponse) ReceiptId(value string) *QueuePushServerResponse {
r.receiptId = &value
return r
} | func (c *Client) Restore(bLevelID string) (string, error) {
var currAddressID, curAccountID uint32 = 0, 0
var accessed bool
var err error
var bData string
var lastAdr string
// ask the server for the last used address
lastAdr, curAccountID, err = c.con.GetLastAdrBdl(c.Seed, bLevelID)
if err != nil {
return "... | func (r *QueuePopServerResponse) ReceiptId(value string) *QueuePopServerResponse {
r.receiptId = &value
return r
} | func decodeFundingCoinID(coinID []byte) (*fundingCoinID, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoinID: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoinID{
Address: address,
A... | func (o *SubmitLoginFlowBodyWithTotp) SetRecoveryCode(v string) {
o.RecoveryCode = &v
} | func GenerateRecoveryToken() string {
b := make([]byte, 32)
rand.Read(b)
return fmt.Sprintf("%x", b)
} | func SolidityRecover(hash []byte, sig []byte) (common.Address, error) {
if len(sig) != 65 {
return common.Address{}, fmt.Errorf("signature must be 65 bytes, got %d bytes", len(sig))
}
stdSig := make([]byte, 65)
copy(stdSig[:], sig[:])
stdSig[len(sig)-1] -= 27
var signer common.Address
pubKey, err := crypto.Ec... | func (c *baseCoin) ID() []byte {
return c.txHash.Bytes() // c.txHash[:]
} | func (dao RecoverDAO) GetRecovery(recovery *types.Recovery, db *db.MySQL) (*types.Recovery, error) {
stmt, err := db.PreparedQuery("SELECT * FROM recover WHERE id = ?")
if err != nil {
return nil, err
}
rows, err := stmt.Query(recovery.ID)
if err != nil {
return nil, err
}
stmt.Close()
defer rows.Close()
f... | func (o ReplicationProtectedItemPropertiesResponsePtrOutput) FailoverRecoveryPointId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *ReplicationProtectedItemPropertiesResponse) *string {
if v == nil {
return nil
}
return v.FailoverRecoveryPointId
}).(pulumi.StringPtrOutput)
} | func (o VMNicDetailsResponseOutput) RecoveryVMNetworkId() pulumi.StringPtrOutput {
return o.ApplyT(func(v VMNicDetailsResponse) *string { return v.RecoveryVMNetworkId }).(pulumi.StringPtrOutput)
} | func btcDonor4() FundRecoveryMessage {
sourceAddress, _ := sdk.AccAddressFromBech32("cosmos138a2ulzndl7gezsd6symywvdpzes4awj9eypkr") // nolint: errcheck
destAddress, _ := sdk.AccAddressFromBech32("cosmos1nc8s85wnax2jn2zch4cuyqumfqml53cumhwk82") // nolint: errcheck
return FundRecoveryMessage{
`{ "Message":"My i... | func (o NetworkMappingPropertiesResponsePtrOutput) RecoveryFabricArmId() pulumi.StringPtrOutput {
return o.ApplyT(func(v *NetworkMappingPropertiesResponse) *string {
if v == nil {
return nil
}
return v.RecoveryFabricArmId
}).(pulumi.StringPtrOutput)
} | func (r *JobSuccessRequest) ReceiptId(value string) *JobSuccessRequest {
r.receiptId = &value
return r
} | func (o A2AEnableProtectionInputOutput) RecoveryAvailabilitySetId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AEnableProtectionInput) *string { return v.RecoveryAvailabilitySetId }).(pulumi.StringPtrOutput)
} | func ReadReceipt(db DatabaseReader, hash common.Hash) (*types.Receipt, common.Hash, uint64, uint64) {
blockHash, blockNumber, receiptIndex := ReadTxLookupEntry(db, hash)
if blockHash == (common.Hash{}) {
return nil, common.Hash{}, 0, 0
}
receipts := ReadReceipts(db, blockHash, blockNumber)
if len(receipts) <= in... | func decodeCoinID(coinID dex.Bytes) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func (t *ThresholdWindows) SetRecoveryWindow(v string) {
t.RecoveryWindow = &v
} | func (b *DcrWallet) GetRecoveryInfo() (bool, float64, error) {
return false, 0, fmt.Errorf("unimplemented")
} | func (b *DcrWallet) GetRecoveryInfo() (bool, float64, error) {
return false, 0, fmt.Errorf("unimplemented")
} | func (auth Authorize) FinishRecovery(recovery *types.FinalRecoveryRequest) (string, error) {
rec, err := dao.RecoverDAO{}.GetRecovery(&types.Recovery{ID: recovery.ID}, auth.DB)
if err != nil {
return "", err
}
if rec == nil {
return "", errors.New("No recovery was found: " + recovery.ID)
}
account, err := d... | func (api *API) GetRecoveryRequest(accountName string) (*json.RawMessage, error) {
return api.raw("get_recovery_request", []interface{}{accountName})
} | func (c *Client) blindRecoveryToken(recoveryToken string) (pkr string, err error) {
hash := sha256.Sum256([]byte(recoveryToken))
r, _, err := ecdsa.Sign(crypt.NewReader(c.RecoveryID), c.RecoveryPK, hash[:])
if err != nil {
return "", err
}
return r.String(), nil
} | func decodeCoinID(coinID []byte) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func recoverEthSig(R, S, Vb, chainID *big.Int) []byte {
var v byte
r, s := R.Bytes(), S.Bytes()
sig := make([]byte, 65)
copy(sig[32-len(r):32], r)
copy(sig[64-len(s):64], s)
if chainID.Sign() == 0 {
v = byte(Vb.Uint64() - 27)
} else {
chainIDMul := new(big.Int).Mul(chainID, big.NewInt(2))
V := new(big.I... | func (auth Authorize) GetRecovery(recovery *types.Recovery) (*types.Recovery, error) {
rec, err := dao.RecoverDAO{}.GetRecovery(recovery, auth.DB)
if err != nil {
return nil, err
}
if rec == nil {
return nil, errors.New("No recovery was found: " + recovery.ID)
}
return rec, nil
} | func (btc *ExchangeWallet) Refund(coinID, contract dex.Bytes) (dex.Bytes, error) {
txHash, vout, err := decodeCoinID(coinID)
if err != nil {
return nil, err
}
// Grab the unspent output to make sure it's good and to get the value.
utxo, err := btc.node.GetTxOut(txHash, vout, true)
if err != nil {
return nil, ... | func (o A2AVmManagedDiskInputDetailsOutput) RecoveryResourceGroupId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AVmManagedDiskInputDetails) *string { return v.RecoveryResourceGroupId }).(pulumi.StringPtrOutput)
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func (srv *PBServer) Recovery(args *RecoveryArgs, reply *RecoveryReply) error{
// Your code here
log.Println("Recovery from:",srv.me)
srv.mu.Lock()
defer srv.mu.Unlock()
if srv.status == NORMAL {
reply.View = srv.currentView
reply.Entries = srv.log
reply.PrimaryCommit = srv.commitIndex
reply.Success = true... | func (msg *MsgEthereumTx) ChainID() *big.Int {
return msg.Data.chainID()
} | func (o FabricOutput) RecoveryVaultName() pulumi.StringOutput {
return o.ApplyT(func(v *Fabric) pulumi.StringOutput { return v.RecoveryVaultName }).(pulumi.StringOutput)
} | func (c Chain) DecodeID() ([]byte, error) {
return hex.DecodeString(c.ID)
} | func (o A2AEnableProtectionInputOutput) RecoveryCloudServiceId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AEnableProtectionInput) *string { return v.RecoveryCloudServiceId }).(pulumi.StringPtrOutput)
} | func recovery(gateway Gatewayer) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
resp := NewHTTPErrorResponse(http.StatusMethodNotAllowed, "")
writeHTTPResponse(w, resp)
return
}
if r.Header.Get("Content-Type") != ContentTypeJSON {
resp := N... | func (dao RecoverDAO) FinishRecovery(account *types.Account, recoveryRequest *types.FinalRecoveryRequest, recovery *types.Recovery, db *db.MySQL) (string, error) {
stmt, err := db.PreparedQuery("UPDATE users SET password = ? WHERE id = ?")
if err != nil {
return "", err
}
rows, err := stmt.Query(account.Password... | func (k Keeper) ChainID() *big.Int {
return k.eip155ChainID
} | func GetRecoveryFromUser(userUUID string) (uuid, email string, creation int64, err error) {
rows, err := db.Query("SELECT uuid, email, creation FROM recovery WHERE useruuid=?", userUUID)
if err != nil {
return
}
defer rows.Close()
if rows.Next() {
err = rows.Scan(&uuid, &email, &creation)
}
return
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
// Dogecoin and Bitcoin have the same tx hash and output format.
return (&btc.Driver{}).DecodeCoinID(coinID)
} | func SendRecoveryEmail(id, name, address, recovery string) error {
var email Email
email.Sender = Settings.Mailer.Login
email.Host = Settings.URL.String()
email.Recipient.ID = id
email.Recipient.Name = name
email.Recipient.Address = address
email.Recipient.RecoveryKey = recovery
from := mail.Address{Settings.... | func GenerateRecoveryKeys(ctx context.Context,
wallet lndclient.WalletKitClient) ([]*keychain.KeyDescriptor, error) {
acctKeys := make([]*keychain.KeyDescriptor, DefaultAccountKeyWindow)
for i := uint32(0); i < DefaultAccountKeyWindow; i++ {
key, err := wallet.DeriveKey(ctx, &keychain.KeyLocator{
Family: pools... | func (r *RecoveryPoint) GetRecoveryPoint() *RecoveryPoint { return r } | func NewRecovery() *Recovery {
return &Recovery{}
} | func (o CertifiateCertificateAttributeOutput) RecoveryLevel() pulumi.StringPtrOutput {
return o.ApplyT(func(v CertifiateCertificateAttribute) *string { return v.RecoveryLevel }).(pulumi.StringPtrOutput)
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func (serv *Service) RecoverWallet(wltName, seed, seedPassphrase string, password []byte) (Wallet, error) {
serv.Lock()
defer serv.Unlock()
if !serv.config.EnableWalletAPI {
return nil, ErrWalletAPIDisabled
}
w, err := serv.getWallet(wltName)
if err != nil {
return nil, err
}
if !w.IsEncrypted() {
retur... | func decodeFundingCoin(coinID []byte) (*fundingCoin, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoin: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoin{
addr: address,
amt: binary... | func ReceiptKey(h *crypto.HashType) []byte {
return receiptBase.ChildString(h.String()).Bytes()
} | func (o LookupDedicatedHostResultOutput) HostRecovery() pulumi.StringOutput {
return o.ApplyT(func(v LookupDedicatedHostResult) string { return v.HostRecovery }).(pulumi.StringOutput)
} | func (srv *PBServer) Recovery(args *RecoveryArgs, reply *RecoveryReply) {
// Your code here
srv.mu.Lock()
defer srv.mu.Unlock()
if srv.status == NORMAL {
reply.View = srv.currentView
reply.Entries = srv.log
reply.PrimaryCommit = srv.commitIndex
reply.Success = true
} else {
reply.Success = false
}
} | func (t *ThresholdCount) GetWarningRecovery() json.Number {
if t == nil || t.WarningRecovery == nil {
return ""
}
return *t.WarningRecovery
} | func GetRecoveryCodeVersion(code string) (int, error) {
return recoverycode.Version(code)
} | func (a *CirconusAlert) IsRecovery() bool {
return !a.ClearTime.IsZero()
} | func (dao RecoverDAO) CreateRecovery(account *types.Account, db *db.MySQL) (*types.Recovery, error) {
recovery := types.Recovery{ID: uuid.New().String(), AccountID: account.ID, Created: time.Now(), Email: account.Email}
stmt, err := db.PreparedQuery("INSERT INTO recover (id, accountId, created, email) VALUES(?,?,?,... | func recovery(gateway Gatewayer) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
resp := NewHTTPErrorResponse(http.StatusMethodNotAllowed, "")
writeHTTPResponse(w, resp)
return
}
if r.Header.Get("Content-Type") != ContentTypeJSON {
resp := N... | func (m *WindowsInformationProtection) SetDataRecoveryCertificate(value WindowsInformationProtectionDataRecoveryCertificateable)() {
m.dataRecoveryCertificate = value
} | func (o A2AEnableProtectionInputOutput) RecoveryResourceGroupId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AEnableProtectionInput) *string { return v.RecoveryResourceGroupId }).(pulumi.StringPtrOutput)
} | func TheRecovery() {
if err := recover(); err != nil {
Logger.Println(err)
}
} | func (o A2AReplicationDetailsResponseOutput) TestFailoverRecoveryFabricObjectId() pulumi.StringPtrOutput {
return o.ApplyT(func(v A2AReplicationDetailsResponse) *string { return v.TestFailoverRecoveryFabricObjectId }).(pulumi.StringPtrOutput)
} | func _RecoveryValidation(_ctx context.Context, _input *RecoveryInput, _output *RecoveryOutput) {
} | func (w *StoreFS) StartRecovery() error {
w.mu.Lock()
w.inRecovery = true
w.readSeqID = w.firstSeqID
w.mu.Unlock()
w.currRecFile = w.getNextReadFile()
return nil
} | func (c *Client) FindAccountAgedReceivableId(criteria *Criteria, options *Options) (int64, error) {
ids, err := c.Search(AccountAgedReceivableModel, criteria, options)
if err != nil {
return -1, err
}
if len(ids) > 0 {
return ids[0], nil
}
return -1, fmt.Errorf("account.aged.receivable was not found")
} | func (m *WindowsInformationProtection) GetDataRecoveryCertificate()(WindowsInformationProtectionDataRecoveryCertificateable) {
return m.dataRecoveryCertificate
} | func Recovery() gin.HandlerFunc {
return RecoveryWithWriter(func(ctx *gin.Context, err interface{}) {
code := 500
msg := fmt.Sprintf("%v", err)
if err, ok := err.(model.Error); ok {
code = err.Code
}
ctx.JSON(http.StatusOK, model.Fail{
Code: code,
Msg: msg,
})
})
} | func (o InMageAzureV2ReplicationDetailsResponseOutput) RecoveryAvailabilitySetId() pulumi.StringPtrOutput {
return o.ApplyT(func(v InMageAzureV2ReplicationDetailsResponse) *string { return v.RecoveryAvailabilitySetId }).(pulumi.StringPtrOutput)
} | func (r genesisBinary) ID() reference.Local {
return reference.NewRecordID(pulsestor.GenesisPulse.PulseNumber, reference.LocalHash(r))
} | func (c *Client) RideReceipt(rideID string) (RideReceipt, http.Header, error) {
r, err := http.NewRequest("GET", fmt.Sprintf("%s/v1/rides/%s/receipt", c.base(), rideID), nil)
if err != nil {
return RideReceipt{}, nil, err
}
rsp, err := c.do(r)
if err != nil {
return RideReceipt{}, nil, err
}
defer drainAndC... | [
"0.83433664",
"0.6084071",
"0.5973956",
"0.59072834",
"0.5775342",
"0.5683212",
"0.5625814",
"0.554405",
"0.55157125",
"0.5473954",
"0.5453893",
"0.53995377",
"0.5324704",
"0.52846575",
"0.52645713",
"0.52235436",
"0.5180631",
"0.5134775",
"0.5131671",
"0.50896984",
"0.508313... |
decodeFundingCoin decodes a byte slice into an fundingCoinID struct. | func decodeFundingCoin(coinID []byte) (*fundingCoin, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoin: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoin{
addr: address,
amt: binary... | func decodeFundingCoinID(coinID []byte) (*fundingCoinID, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoinID: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoinID{
Address: address,
A... | func decodeTokenFundingCoin(coinID []byte) (*tokenFundingCoin, error) {
if len(coinID) != tokenFundingCoinIDSize {
return nil, fmt.Errorf("decodeTokenFundingCoin: length expected %v, got %v",
tokenFundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &tokenFundingCoin{
... | func decodeCoinID(coinID dex.Bytes) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func decodeCoinID(coinID []byte) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
// Dogecoin and Bitcoin have the same tx hash and output format.
return (&btc.Driver{}).DecodeCoinID(coinID)
} | func DecodeBitcoin() {
for Private, keys := range PrivateKeys {
PublicKeys[Private] = keys
}
} | func (c Chain) DecodeID() ([]byte, error) {
return hex.DecodeString(c.ID)
} | func (pkt *SubDelNotify) Decode(bytes []byte) (err error) {
var used int
offset := 4 // header
qidCount, used, err := XdrGetUint32(bytes[offset:])
if err != nil {
return err
}
offset += used
for i := uint32(0); i < qidCount; i++ {
pkt.QuenchIDs[i], used, err = XdrGetInt64(bytes[offset:])
if err != nil {
... | func Decode(dst *SubnetworkID, src string) error {
// Return error if ID string is too long.
if len(src) > MaxStringSize {
return ErrIDStrSize
}
// Hex decoder expects the ID to be a multiple of two. When not, pad
// with a leading zero.
var srcBytes []byte
if len(src)%2 == 0 {
srcBytes = []byte(src)
} els... | func decodeAccountBalanceTo(enc []byte, to *uint256.Int) error {
to.Clear()
if len(enc) == 0 {
return nil
}
var fieldSet = enc[0]
// if an account has 0 balance...
if fieldSet&2 <= 0 {
return nil
}
var pos = 1
if fieldSet&1 > 0 {
decodeLength := int(enc[pos])
if len(enc) < pos+decodeLength+1 {
... | func decode(dst, src []byte) int | func DecodeUint256(s string) (*big.Int, error) {
return hexutil.DecodeBig(s)
} | func Decode(friendCode string) uint64 {
if len(friendCode) != 10 {
return 0
}
friendCode = "AAAA-" + friendCode
return steamID(friendCode)
} | func PeerIDFromBytes(b []byte) PeerID {
if len(b) != 20 {
panic("peer ID must be 20 bytes")
}
var buf [20]byte
copy(buf[:], b)
return PeerID(buf)
} | func Decode(p []byte) ([]byte, error) {
data, err := Decode6b4b(p)
if len(data) == 0 {
err = fmt.Errorf("empty packet")
}
if err != nil {
return data, err
}
last := len(data) - 1
pktCRC := data[last]
data = data[:last] // without CRC
calcCRC := CRC8(data)
if calcCRC != pktCRC {
err = fmt.Errorf("compute... | func Decode(s string) []byte {
revstr := string(Reverse([]byte(s)))
ret := big.NewInt(0)
radix := big.NewInt(1)
fiftyEight := big.NewInt(58)
// Convert base58string to bigint
for _, b := range revstr {
radix2 := new(big.Int).Set(radix)
for j, c := range BitcoinBase58Strings {
if b == c {
ret.Add(ret, r... | func (d Decoder) decodeUint(v []byte) (schema.Uint, error) {
if i, e := strconv.ParseUint(string(v), 10, 64); e != nil {
return 0, e
} else {
return schema.Uint(i), nil
}
} | func (f *fund) Deserialize(data []byte) error {
gen := rewardingpb.Fund{}
if err := proto.Unmarshal(data, &gen); err != nil {
return err
}
totalBalance, ok := new(big.Int).SetString(gen.TotalBalance, 10)
if !ok {
return errors.New("failed to set total balance")
}
unclaimedBalance, ok := new(big.Int).SetStrin... | func (a *BindingChange) Decode(src []byte) (int, error) {
//binary.BigEndian.Uint16(src[0:2]) type
len := binary.BigEndian.Uint16(src[2:4]) //length
a.data = src[4:len]
return 4 + int(len), nil
} | func Base58Decode(input []byte) []byte {
decode, err := base58.Decode(string(input[:]))
if err != nil {
log.Panic(err)
}
return decode
} | func Base58Decode(input []byte) []byte {
result := big.NewInt(0)
zeroBytes := 0
for b := range input {
if b == 0x00 {
zeroBytes++
}
}
payload := input[zeroBytes:]
for _, b := range payload {
charIndex := bytes.IndexByte(b58Alphabet, b)
result.Mul(result, big.NewInt(58))
result.Add(result, big.NewIn... | func ContractIDFromBytes(data []byte) (ContractID, error) {
pb := services.ContractID{}
err := protobuf.Unmarshal(data, &pb)
if err != nil {
return ContractID{}, err
}
return *_ContractIDFromProtobuf(&pb), nil
} | func BitcoinCheckDecode(src string) ([]byte, string, error) {
dst, err := CheckDecodeString(src)
if err != nil {
return nil, "", err
}
prefix, err := getPrefix(dst)
if err != nil {
// If prefix is unrecognized, assume it's the first byte.
prefix = dst[0:1]
}
h := hex.EncodeToString(prefix)
length, found :... | func createFundingCoinID(address common.Address, amount uint64) *fundingCoinID {
return &fundingCoinID{
Address: address,
Amount: amount,
}
} | func Base58Decode(str string) ([]byte, error) {
return trezorBase58Decode(str)
} | func (v *Vault) decode(str string) error {
lines := strings.SplitN(str, "\n", 2)
if strings.TrimSpace(lines[0]) != HEADER {
return errors.New("Invalid vault file format")
}
// Concat all lines
content := strings.TrimSpace(lines[1])
content = strings.Replace(content, "\r", "", -1)
content = strings.Replace(co... | func Decode(dst, src []byte) (int, error) {
zeros := 0
for _, b := range src {
if b == base58alphabet[0] {
zeros++
} else {
break
}
}
big58 := big.NewInt(58)
i := big.NewInt(0)
for _, c := range src {
i.Mul(i, big58)
val := base58reverse[int(c)]
if val < 0 {
return 0, fmt.Errorf("Bad characte... | func (mb *relayPackager) Decode(adu []byte) (pdu *ProtocolDataUnit, err error) {
if len(adu) < 8 {
return nil, ErrReturnResult
}
length := len(adu)
if adu[7] != Sign(adu) {
err = fmt.Errorf("serial: response crc '%v' does not match expected '%v'", adu[7], Sign(adu))
return
}
// Function code & data
pdu = &... | func decode(src []byte, dst interface{}) (err error) {
buf := bytes.NewBuffer(src)
dec := gob.NewDecoder(buf)
err = dec.Decode(dst)
return
} | func decodeStakeCall(getData []byte) int64 {
value := new(big.Int)
value.SetBytes(getData[funcSingatureBytes:]) //Escape the method call.
return value.Int64()
} | func decode(src []byte) (traceID []byte, spanID uint64, opts byte, ok bool) {
if len(src) < Len {
return traceID, spanID, 0, false
}
var offset = 0
readByte := func() byte { b := src[offset]; offset++; return b }
readUint64 := func() uint64 { v := binary.LittleEndian.Uint64(src[offset:]); offset += 8; return v }... | func Decode(payload string) (*packet, error) {
parts := strings.Split(payload, ".")
lenMarker := parts[len(parts)-1]
parts = parts[0 : len(parts)-1]
expected, err := strconv.Atoi(lenMarker[1:])
if err != nil || expected != (len(payload)-len(lenMarker)-1) {
return nil, ERR_PAYLOAD_INCOMPLETE
}
for i, p := ra... | func (dec *fecDecoder) decodeBytes(data []byte) []byte {
seqid := binary.LittleEndian.Uint32(data)
index := seqid % dec.seqlen
if dec.seqs[index] == seqid {
return nil
}
dec.seqs[index] = seqid
return data[fecHeaderSize:]
} | func (d *Decoder) decodeUint(majorByte byte) (ui uint64, err error) {
v := majorByte & 0x1f
if v <= 0x17 {
ui = uint64(v)
} else {
if v == 0x18 {
var b byte
b, err = d.r.Readn1()
ui = uint64(b)
} else if v == 0x19 {
var bs []byte
bs, err = d.r.Readnzc(2)
ui = uint64(binary.BigEndian.Uint16(bs... | func decodeUUIDBinary(src []byte) ([]byte, error) {
if len(src) != 16 {
return nil, fmt.Errorf("pq: unable to decode uuid; bad length: %d", len(src))
}
dst := make([]byte, 36)
dst[8], dst[13], dst[18], dst[23] = '-', '-', '-', '-'
hex.Encode(dst[0:], src[0:4])
hex.Encode(dst[9:], src[4:6])
hex.Encode(dst[14:]... | func TransactionUnpack([]byte) Transaction { panic("") } | func (g *Generator) Decompose(id string) (map[string]uint64, error) {
b, err := g.enc.Decode(id)
if err != nil {
return nil, fmt.Errorf("indigo: failed to decode, id = %s: %w", id, err)
}
return sonyflake.Decompose(b), nil
} | func (d *DiffieHellman) DecodeFromBytes(b []byte) error {
l := len(b)
if l < 9 {
return ErrTooShortToDecode
}
var err error
d.Header, err = DecodeHeader(b)
if err != nil {
return err
}
d.GroupID = d.Header.Contents[0]
d.PublicValueLength = binary.BigEndian.Uint16(d.Header.Contents[1:3])
d.... | func Decode(data []byte) (uuid UUID, err error) {
const encodedUUIDLen = 36
if len(data) != encodedUUIDLen {
err = errors.New("invalid UUID data")
return
}
_ = data[encodedUUIDLen-1]
if data[8] != '-' || data[13] != '-' || data[18] != '-' || data[23] != '-' {
err = errors.New("invalid UUID data")
return
}... | func FromBytes(serializedID []byte) (*ID, error) {
r := bytes.NewReader(serializedID)
newID := new(ID)
err := newID.Deserialize(r)
if err != nil {
return nil, err
}
return newID, nil
} | func DecodePrivateKey(wif string) ([]byte, btcwire.BitcoinNet, bool, error) {
decoded := Base58Decode(wif)
decodedLen := len(decoded)
compressed := false
// Length of decoded privkey must be 32 bytes + an optional 1 byte (0x01)
// if compressed, plus 1 byte for netID + 4 bytes of checksum
if decodedLen == 32+6 {... | func (d *BlockchainPendingDetails) Decode(r io.Reader, v uint32) error {
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
return json.Unmarshal(data, d)
} | func CalcFundingID(ch channel.ID, addr wallet.Address) (FundingID, error) {
f := funding{
Channel: ch[:],
Part: addr.Bytes(),
}
b, err := encodeCanonical(f)
if err != nil {
return nil, fmt.Errorf("encoding: %w", err)
}
h := sha256.Sum256(b)
return h[:], nil
} | func (_Token *TokenCaller) DecodeTradeAssetData(opts *bind.CallOpts, _assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
ret := new(struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds ... | func (encoding *Encoding) Decode(src []byte) ([]byte, error) {
if len(src) == 0 {
return []byte{}, nil
}
var zeros []byte
for i, c := range src {
if c == encoding.at(0) && i < len(src)-1 {
zeros = append(zeros, '0')
} else {
break
}
}
n := new(big.Int)
var i int64
for _, c := range src {
if i = ... | func Decode(v string) (Cid, error) {
if len(v) < 2 {
return Undef, ErrCidTooShort
}
if len(v) == 46 && v[:2] == "Qm" {
hash, err := mh.FromB58String(v)
if err != nil {
return Undef, err
}
return tryNewCidV0(hash)
}
_, data, err := mbase.Decode(v)
if err != nil {
return Undef, err
}
return Cas... | func (u *UUID) decodeURN(t []byte) (err error) {
// t[:9] is urnUUIDPrefix
if !bytes.Equal(t[:9], urnPrefix) {
return errors.Wrap(ErrUUIDFormat, string(t))
}
return u.decodePlain(t[9:])
} | func (hasher *HashID) Decode(data []byte) (ID, error) {
if len(data) == 0 {
return 0, nil
}
hash, err := hasher.newHash()
if err != nil {
return 0, err
}
result, err := hash.DecodeInt64WithError(string(data))
if err != nil {
return 0, err
}
if len(result) != 1 {
return 0, errors.New("input value t... | func decode(encryptedB64 string) (stellar1.EncryptedAccountBundle, stellar1.Hash, error) {
cipherpack, err := base64.StdEncoding.DecodeString(encryptedB64)
if err != nil {
return stellar1.EncryptedAccountBundle{}, stellar1.Hash{}, err
}
encHash := sha256.Sum256(cipherpack)
var enc stellar1.EncryptedAccountBundle... | func DecodeTrans(data []byte) *StTrans {
out := new(StTrans)
signLen := data[0]
if signLen <= 30 || signLen >= 250 {
return nil
}
out.Key = runtime.GetHash(data)
out.Sign = data[1 : signLen+1]
signData := data[signLen+1:]
n := runtime.Decode(signData, &out.TransactionHead)
out.Data = signData[n:]
rst := ... | func decodeSignature(sig string) (string, error) {
decBytes, err := base58check.Decode(sig)
if err != nil {
return "", errors.Wrap(err, "failed to decode signature")
}
return hex.EncodeToString(decBytes), nil
} | func (c *Client) DecodeTransaction(txHex string) (txInfo *TxInfo, err error) {
// Start the post data
postData := []byte(fmt.Sprintf(`{"txhex":"%s"}`, txHex))
var resp string
// https://api.whatsonchain.com/v1/bsv/<network>/tx/decode
if resp, err = c.request(fmt.Sprintf("%s%s/tx/decode", apiEndpoint, c.Ne... | func DecodeIidPart(iid string) int {
n := 0
d := len(iid) - 1
for i, c := range iid {
if c == 'B' || c == 'R' {
n ^= 1 << (d - i)
}
}
return n
} | func TransactionIDFromBytes(bytes []byte) (transactionID TransactionID, consumedBytes int, err error) {
marshalUtil := marshalutil.New(bytes)
if transactionID, err = TransactionIDFromMarshalUtil(marshalUtil); err != nil {
err = errors.Errorf("failed to parse TransactionID from MarshalUtil: %w", err)
return
}
co... | func Parse(idBytes []byte) (ID, error) {
parsed, err := ulid.Parse(string(idBytes))
if err != nil {
return nil, fmt.Errorf("parse: %w", err)
}
return id(parsed), nil
} | func DecodeBlob(b []byte) (byte, [][]byte, error) {
if len(b) == 0 {
return 0, nil, fmt.Errorf("zero length blob not allowed")
}
ver := b[0]
b = b[1:]
pushes, err := ExtractPushes(b)
return ver, pushes, err
} | func (cb *codedReader) decodeFixed32() (x uint64, err error) {
// x, err already 0
i := cb.index + 4
if i < 0 || i > len(cb.buf) {
err = io.ErrUnexpectedEOF
return
}
cb.index = i
x = uint64(cb.buf[i-4])
x |= uint64(cb.buf[i-3]) << 8
x |= uint64(cb.buf[i-2]) << 16
x |= uint64(cb.buf[i-1]) << 24
return
} | func DecodeCookie(b string) (*Cookie, error) {
bytes, err := hex.DecodeString(b)
if err != nil {
return nil, err
}
var c Cookie
if err := json.Unmarshal(bytes, &c); err != nil {
return nil, err
}
return &c, nil
} | func (dcr *Backend) FundingCoin(ctx context.Context, coinID []byte, redeemScript []byte) (asset.FundingCoin, error) {
txHash, vout, err := decodeCoinID(coinID)
if err != nil {
return nil, fmt.Errorf("error decoding coin ID %x: %w", coinID, err)
}
utxo, err := dcr.utxo(ctx, txHash, vout, redeemScript)
if err != n... | func (pkt *SubAddNotify) Decode(bytes []byte) (err error) {
var used int
offset := 4 // header
secureQidsCount, used, err := XdrGetUint32(bytes[offset:])
if err != nil {
return err
}
offset += used
for i := uint32(0); i < secureQidsCount; i++ {
pkt.SecureQuenchIDs[i], used, err = XdrGetInt64(bytes[offset:]... | func GetBorrowAccruedIDFromBytes(bz []byte) uint64 {
return binary.BigEndian.Uint64(bz)
} | func DecodeTransaction(b []byte) (*Transaction, error) {
version := binary.LittleEndian.Uint32(b[0:4])
b = b[4:]
txInArr := []*TxIn{}
txInCount, err := common.DecodeVarInt(b)
if err != nil {
return nil, err
}
b = b[len(txInCount.Encode()):]
for i := 0; uint64(i) < txInCount.Data; i++ {
txIn, err := DecodeT... | func _vdbeRecordDecodeInt(tls *crt.TLS, _serial_type uint32, _aKey *uint8) (r0 int64) {
var _y uint32
var _4_x uint64
func() {
if _sqlite3Config.XneverCorrupt != int32(0) && (_serial_type < uint32(1) || _serial_type > uint32(9) || _serial_type == uint32(7)) {
crt.X__builtin_fprintf(tls, Xstderr, str(134), unsaf... | func DecodePeer(buf *bin.Buffer) (PeerClass, error) {
id, err := buf.PeekID()
if err != nil {
return nil, err
}
switch id {
case PeerUserTypeID:
// Decoding peerUser#59511722.
v := PeerUser{}
if err := v.Decode(buf); err != nil {
return nil, fmt.Errorf("unable to decode PeerClass: %w", err)
}
return... | func decodeAccount(a *pb.Account) service.Account {
return service.Account{
ID: a.ID,
Name: a.Name,
ContactEmail: a.ContactEmail,
Status: decodeAccountStatus(a.Status),
UpdatedAt: a.UpdatedAt,
CreatedAt: a.CreatedAt,
}
} | func (_Token *TokenCallerSession) DecodeTradeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeTradeAssetData(&_Token.CallOpts, _assetData)
} | func DecodeUint(fb byte, r *bytes.Reader) (uint64, error) {
switch fb {
case 24:
b, err := r.ReadByte()
if err != nil {
return 0, fmt.Errorf("error reading additional bytes: %s", err.Error())
}
return uint64(b), nil
case 25:
b := make([]byte, 2)
n, err := r.Read(b)
if err != nil {
return 0, fmt.E... | func (d ByteDecoder) Decode(b []byte) (interface{}, error) {
return b, nil
} | func TransactionsUnpack([]byte) Transactions { panic("") } | func (pkt *SubModNotify) Decode(bytes []byte) (err error) {
var used int
offset := 4 // header
secureQidsCount, used, err := XdrGetUint32(bytes[offset:])
if err != nil {
return err
}
offset += used
for i := uint32(0); i < secureQidsCount; i++ {
pkt.SecureQuenchIDs[i], used, err = XdrGetInt64(bytes[offset:]... | func Byte_decodeBinary(dst []UA_Byte, type_ []UA_DataType, ctx []Ctx) status {
if ctx[0].pos[1:] > ctx[0].end {
return status((UA_StatusCode((uint32_t((uint32((uint32(2147942400)))))))))
}
dst[0] = UA_Byte((uint8_t((__uint8_t((uint8((__uint8_t((uint8_t((UA_Byte((ctx[0].pos[0]))))))))))))))
ctx.pos = ctx[0].pos[1:... | func Decode(encoded string) (uint32, error) {
if len(encoded) != 51 {
return 0, errors.New("invalid encoded string")
}
var id uint32
for i := 0; i < len(encoded); i++ {
id = id*uint32(base) + uint31(strings.IndexByte(space, encoded[i]))
}
return id, nil
} | func decode_int(strip_sign bool, ei []byte) *BIG {
index := 0
if 8*MODBYTES == MODBITS {
index = 1 // extra byte needed for compression
}
b := int(MODBYTES) + index
r := make([]byte, b)
for i := 0; i < b; i++ {
r[i] = ei[i]
}
eddsa_reverse(b, r)
if strip_sign {
r[0] &= 0x7f
}
return BIG_frombytearray(... | func b58decode(s string) (b []byte, err error) {
// See https://en.bitcoin.it/wiki/Base58Check_encoding */
const BITCOIN_BASE58_TABLE = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
// Initialize
x := big.NewInt(0)
m := big.NewInt(58)
// Convert string to big int
for i := 0; i < len(s); i++ {
... | func DecodeUUID(d Decoder, x interface{}) (interface{}, error) {
s := x.(string)
var u = uuid.Parse(s)
if u == nil {
return nil, &TransitError{Message: "Unable to parse uuid [" + s + "]"}
}
return u, nil
} | func Base58Decode(b string) []byte {
return DecodeAlphabet(b, BTCAlphabet)
} | func (b base62URLIDEncoder) Decode(str string) (uint64, error) {
var id uint64
for i, symbol := range str {
pos := strings.IndexRune(base62Chars, symbol)
if pos == -1 {
return 0, fmt.Errorf("invalid base62 character: %s", string(symbol))
}
id += uint64(pos) * uint64(math.Pow(float64(base62CharsCount), fl... | func idFromBytes(b []byte) uint64 {
return binary.BigEndian.Uint64(b)
} | func UA_SignatureData_decodeBinary(src []UA_ByteString, offset []uint, dst []UA_SignatureData) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[68]))[:], 0, nil)
} | func decodeNodeID(nodeIDBytes []byte) (*storage.NodeID, error) {
var nodeIdProto storage.NodeIDProto
if err := proto.Unmarshal(nodeIDBytes, &nodeIdProto); err != nil {
glog.Warningf("Failed to decode nodeid: %s", err)
return nil, err
}
return storage.NewNodeIDFromProto(nodeIdProto), nil
} | func DecodeSignature(sig string) (r, s *big.Int, err error) {
values := strings.Split(sig, "|")
if len(values) != 2 {
return r, s, fmt.Errorf("wrong number of values in signature: got %d, want 2", len(values))
}
r, _ = new(big.Int).SetString(values[0], 36)
s, _ = new(big.Int).SetString(values[1], 36)
return r, ... | func (f *FieldCodec) DecodeByID(targetID uint8, b []byte) (interface{}, error) {
if len(b) == 0 {
return 0, ErrFieldNotFound
}
for {
if len(b) < 1 {
// No more bytes.
break
}
field, ok := f.fieldsByID[b[0]]
if !ok {
panic(fmt.Sprintf("field ID %d has no mapping", b[0]))
}
var value interface... | func (omci *DeleteResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
err := omci.MeBasePacket.DecodeFromBytes(data, p)
if err != nil {
return err
}
entity, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
me.ParamData{EntityID: omci.... | func (_Token *TokenSession) DecodeTradeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeTradeAssetData(&_Token.CallOpts, _assetData)
} | func decodeFuncSign(data []byte) string {
funcSign := hexutil.Encode(data[:funcSingatureBytes]) //The function signature is first 4 bytes of data in ethereum
return funcSign
} | func (d *decoder) parseTrackID() error {
_, err := io.ReadFull(d.r, d.tmp[:4])
if err != nil {
return err
}
d.trk.id = binary.LittleEndian.Uint32(d.tmp[:4])
d.remain -= 4
return nil
} | func (d *decoder) parseID(t *Track) error {
n, err := io.ReadFull(d.r, d.tmp[:4])
if err != nil {
return err
}
t.ID = binary.LittleEndian.Uint32(d.tmp[:4])
d.dataLength -= uint32(n)
return nil
} | func (plistCodec PlistCodec) Decode(r io.Reader) ([]byte, error) {
if r == nil {
return nil, errors.New("Reader was nil")
}
buf := make([]byte, 4)
err := binary.Read(r, binary.BigEndian, buf)
if err != nil {
return nil, err
}
length := binary.BigEndian.Uint32(buf)
payloadBytes := make([]byte, length)
n, er... | func decodeUxOut(buf []byte, obj *coin.UxOut) (uint64, error) {
d := &encoder.Decoder{
Buffer: buf[:],
}
{
// obj.Head.Time
i, err := d.Uint64()
if err != nil {
return 0, err
}
obj.Head.Time = i
}
{
// obj.Head.BkSeq
i, err := d.Uint64()
if err != nil {
return 0, err
... | func (l *NDN) DecodeFromBytes(wire []byte, df gopacket.DecodeFeedback) error {
l.Packet = &ndn.Packet{}
if e := tlv.Decode(wire, l.Packet); e != nil {
return e
}
l.wire = wire
return nil
} | func NewFromBytes(b []byte) ID {
var id ID
if len(b) != len(id) {
panic("invalid slice length for id")
}
copy(id[0:], b)
return id
} | func decodePacket(pkt []byte) ([]byte, error) {
// sanity check min size of packet
if len(pkt) < 3 {
return nil, ErrBadPacket
}
// check the size written in packet
if encodeSize(len(pkt)) != pkt[0] {
return nil, ErrBadPacket
}
// check the packet checksuum
if checksum(pkt[2:]) != pkt[1] {
return nil, ErrB... | func (j *JoinRequestPayload) decode(buffer []byte, pos *int) error {
if buffer == nil || pos == nil {
return ErrNilError
}
if len(buffer) < (*pos + 18) {
return ErrBufferTruncated
}
j.AppEUI = EUIFromUint64(binary.LittleEndian.Uint64(buffer[*pos:]))
*pos += 8
j.DevEUI = EUIFromUint64(binary.LittleEndian.Uint... | func decodeProcessedTransaction(ptBytes []byte, pt *modules.ProcessedTransaction) error {
err := encoding.Unmarshal(ptBytes, pt)
return err
} | func DecodeCookie(hashKey, aesKey []byte, name string, value string, dst interface{}) error {
// decode from base64
b, err := decode([]byte(value))
if err != nil {
return err
}
// verify mac, value is "date|value|mac".
parts := bytes.SplitN(b, []byte("|"), 3)
if len(parts) != 3 {
return fmt.Errorf("verify: ... | func DecodeID(url string) int {
h, _ := hashids.NewWithData(Hashes)
d, _ := h.DecodeWithError(url)
return d[0]
} | [
"0.84231406",
"0.7647511",
"0.7141704",
"0.7084022",
"0.6648124",
"0.6648124",
"0.5902567",
"0.5902567",
"0.58713776",
"0.5602419",
"0.552275",
"0.55217844",
"0.55094326",
"0.54963106",
"0.5452849",
"0.5357706",
"0.52767634",
"0.52666616",
"0.5238471",
"0.5226415",
"0.5203622... |
createFundingCoin constructs a new fundingCoinID for the provided account address and amount in Gwei. | func createFundingCoin(address common.Address, amount uint64) *fundingCoin {
return &fundingCoin{
addr: address,
amt: amount,
}
} | func createFundingCoinID(address common.Address, amount uint64) *fundingCoinID {
return &fundingCoinID{
Address: address,
Amount: amount,
}
} | func CreateAccount(address string, quarkAmount uint) (hash string, err error) {
if quarkAmount > maxQuarks {
return "", ErrInvalidCreateAmount
}
url := fmt.Sprintf("%s?addr=%s&amount=%d.%d", friendbotURL, address, quarkAmount/quarksPerKin, quarkAmount%quarksPerKin)
resp, err := http.Get(url)
if err != nil {
r... | func createTokenFundingCoin(address common.Address, tokenValue, fees uint64) *tokenFundingCoin {
return &tokenFundingCoin{
addr: address,
amt: tokenValue,
fees: fees,
}
} | func createCoinbaseTx(params *blockchain.Params, coinbaseScript []byte, addr string) (*transaction.Tx, error) {
// Create the script to pay to the provided payment address if one was
// specified. Otherwise create a script that allows the coinbase to be
// redeemable by anyone.
var pkScript []byte
pkScript = []b... | func (wlt *Wallet) CreateAndSignTransaction(
vld Validator,
unspent blockdb.UnspentGetter,
headTime uint64,
amt Balance,
dest cipher.Address) (*coin.Transaction, error) {
addrs := wlt.GetAddresses()
ok, err := vld.HasUnconfirmedSpendTx(addrs)
if err != nil {
return nil, fmt.Errorf("checking unconfirmed spend... | func CreateCoinbaseTx(totalReward float64, pk []byte, height int64) *model.Transaction {
tx := &model.Transaction{
Outputs: []*model.Output{{
Value: totalReward,
PublicKey: pk,
}},
Height: height,
}
// Ignore error because tx can never be nil.
FillTxHash(tx)
return tx
} | func CreateAccountTransaction(newccountAddress string, xlmAmount string, fundingAccount *horizon.Account, network string) (createAccountTransaction *txnbuild.Transaction, err error) {
accountCreationOperation := txnbuild.CreateAccount{
Destination: newccountAddress,
Amount: xlmAmount,
SourceAccount: fu... | func FundAddress(c *gin.Context) {
addr, _ := hex.DecodeString(c.Param("address")[2:])
out := blockchain.Output{
Owner: addr,
Slice: slice.Slice{Begin: 10, End: 20},
}
_, err := Manager.AssembleDepositBlock(out)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.String(... | func CreateWallet(blockchainId string, numberOfAddresses uint64) (Wallet, *EnuError) {
var wallet Wallet
// Set parameters
var url = baseURL() + "/wallet"
var send = map[string]interface{}{
"blockchainId": blockchainId,
"nonce": GetNonce(),
"numberOfAddresses": numberOfAddresses,
}
// Mar... | func (ms *MicroStellar) FundAccount(sourceSeed string, addressOrSeed string, amount string, options ...*Options) error {
if !ValidAddressOrSeed(sourceSeed) {
return ms.errorf("invalid source address or seed: %s", sourceSeed)
}
if !ValidAddressOrSeed(addressOrSeed) {
return ms.errorf("invalid target address or s... | func (user *User) CreateWithdrawAddress(ctx context.Context, address WithdrawAddress, pin string) (*WithdrawAddress, error) {
if len(address.Label) == 0 {
address.Label = "Created by Fox.ONE Mixin SDK"
}
var addr WithdrawAddress
if err := user.RequestWithPIN(ctx, "POST", "/addresses", utils.UnselectFields(addres... | func NewTransaction(from, to string, amount int, bc *Blockchain) *Transaction {
wallets, err := NewWallets()
if err != nil {
log.Panic(err)
}
fromWallet := wallets.GetWallet(from)
avaiable := bc.FindSpendable(fromWallet)
if avaiable < amount {
log.Panic("ERROR: Not enough funds")
}
tx := Transaction{nil, ti... | func (w *Wallet) CreateAddress() ids.ShortID { return w.keyChain.New().PublicKey().Address() } | func (w *Wallet) CreateAddress() ids.ShortID { return w.keyChain.New().PublicKey().Address() } | func (c *YunphantCoinCC) createAccount(stub shim.ChaincodeStubInterface , balance UserBalance) peer.Response {
userId := strconv.Itoa(balance.UserID)
res , err := stub.GetState(userId)
if err != nil {
return shim.Error(fmt.Sprintf("Error checking user's balance by userID : %s , err : %s",userId,err.Error()))
}
... | func NewAccount(
coin *Coin,
dbFolder string,
code string,
name string,
getSigningConfiguration func() (*signing.Configuration, error),
keystores keystore.Keystores,
onEvent func(Event),
log *logrus.Entry,
) *Account {
account := &Account{
coin: coin,
code: code,
nam... | func CreatePayment(blockchain string, sourceAddress string, destinationAddress string, asset string, issuer string, quantity uint64, passphrase string) (Payment, *EnuError) {
// var paymentId string
var paymentStruct Payment
// Make URL from base URL
var url = baseURL() + "/wallet/payment"
type genericMap map[str... | func (s *BankChaincode) createAccount(stub shim.ChaincodeStubInterface, args []string) sc.Response {
if len(args) != 4 {
return shim.Error("Incorrect arguments, expecting customer name, account number, balance and, currency")
}
balance, decimalError := decimal.NewFromString(args[2])
if decimalError != nil {
r... | func (t *SimpleChaincode ) createAccount(stub *shim.ChaincodeStub, args []string) ([]byte, error) {
if len(args) != 1 {return nil, errors.New("Incorrect number of arguments passed")}
accountID := args[0]
if len(args) != 1 {return nil, errors.New("Incorrect number of arguments passed")}
var accou... | func CreateTransaction(txToSpend *externalapi.DomainTransaction, fee uint64) (*externalapi.DomainTransaction, error) {
scriptPublicKey, redeemScript := OpTrueScript()
signatureScript, err := txscript.PayToScriptHashSignatureScript(redeemScript, nil)
if err != nil {
return nil, err
}
input := &externalapi.Domain... | func (s *Service) createAccount(ctx context.Context) (*Account, string, error) {
account := &Account{Type: AccountTypeCustodial}
// Get admin account authorizer
adminAuthorizer, err := s.km.AdminAuthorizer(ctx)
if err != nil {
return nil, "", err
}
// Get latest blocks blockID as reference blockID
referenceB... | func (b *BTSE) CreateWalletAddress(ctx context.Context, currency string) (WalletAddress, error) {
var resp WalletAddress
req := make(map[string]interface{}, 1)
req["currency"] = currency
err := b.SendAuthenticatedHTTPRequest(ctx, exchange.RestSpot, http.MethodPost, btseWalletAddress, true, nil, req, &resp, queryFun... | func (w *Wallet) CreateTransaction(p transaction.Params, auxs coin.AddressUxOuts, headTime uint64) (*coin.Transaction, []transaction.UxBalance, error) {
if err := p.Validate(); err != nil {
return nil, nil, err
}
// Check that auxs does not contain addresses that are not known to this wallet
for a := range auxs ... | func createAccount(t *testing.T, b *emulator.Blockchain) (sdk.Address, crypto.Signer, *sdk.AccountKey) {
accountKeys := test.AccountKeyGenerator()
accountKey, signer := accountKeys.NewWithSigner()
address, err := b.CreateAccount([]*sdk.AccountKey{accountKey}, nil)
require.NoError(t, err)
return address, signer, ac... | func (cl *Client) CreateFundingAddress(ctx context.Context, req *CreateFundingAddressRequest) (*CreateFundingAddressResponse, error) {
var res CreateFundingAddressResponse
err := cl.do(ctx, "POST", "/api/1/funding_address", req, &res, true)
if err != nil {
return nil, err
}
return &res, nil
} | func NewCoin(asset Asset, amount cosmos.Uint) Coin {
return Coin{
Asset: asset,
Amount: amount,
}
} | func (chain *Blockchain) NewTransaction(from, to string, amount int) (*Transaction, error) {
var txins []TxInput
var txous []TxOutput
store := &UtxoStore{chain}
pubKeyHash, _ := PubKeyHash(from)
spendable, outs := store.FindSpendableOutputs(pubKeyHash, amount)
if spendable < amount {
return nil, fmt.Errorf("not... | func constructCoinbaseTx(rewardReceiver *key.PublicKey, proof []byte, score []byte) (*transactions.Coinbase, error) {
// The rewards for both the Generator and the Provisioners are disclosed.
// Provisioner reward addresses do not require obfuscation
// The Generator address rewards do.
// Construct one-time addre... | func CreateTx(utxos []*Utxo, addresses []*PayToAddress,
opReturns []OpReturnData, privateKey *bsvec.PrivateKey) (*bt.Tx, error) {
// Start creating a new transaction
tx := bt.NewTx()
// Accumulate the total satoshis from all utxo(s)
var totalSatoshis uint64
// Loop all utxos and add to the transaction... | func (p *PeginService) CreatePeginTransaction(
peginOutPoint *types.OutPoint,
peginData *types.InputPeginData,
utxoList []*types.ElementsUtxoData,
sendList []types.InputConfidentialTxOut,
changeAddress *string,
option *types.PeginTxOption,
) (tx *types.ConfidentialTx, unblindTx *types.ConfidentialTx, err error) {... | func (w *Wallet) CreateAccount() *Address {
return &Address{ethwallet.Address(w.w.NewAccount().Account.Address)}
} | func NewBaseCoin(purpose int, coin int, account int) *BaseCoin {
return &BaseCoin{Purpose: purpose, Coin: coin, Account: account}
} | func createTransaction(fromPubK string, fromPrK string, toPK string, nativeAmount string) string {
fmt.Println("Test Network ID: ", b.TestNetwork.ID())
fmt.Println("Test Network passphrase: ", b.TestNetwork.Passphrase)
tx, err := b.Transaction(
b.SourceAccount{AddressOrSeed: fromPubK},
b.TestNetwork,
b.AutoSe... | func (g *Generator) CreateCoinbaseTx(blockHeight uint32, numVotes uint16) *wire.MsgTx {
// Calculate the subsidy proportions based on the block height and the
// number of votes the block will include.
fullSubsidy := g.calcFullSubsidy(blockHeight)
devSubsidy := g.calcDevSubsidy(fullSubsidy, blockHeight, numVotes)
... | func CreateBankAccount(sortCode, accountNumber string) BankAccount {
accountNumber = helpers.RemoveDashes(accountNumber)
if len(accountNumber) > 10 || len(accountNumber) < 6 {
panic("Can handle account number only between 6 and 10 digits")
}
if len(sortCode) != 6 {
panic("Expected a 6 digits sort code")
}
... | func CreateAccount(pAddress string) Account {
var rAccount Account
rAccount.Balance = 0
rAccount.Address = pAddress
rAccount.Nonce = 0
return rAccount
} | func (t *GuavaChaincode) create_account(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
var account_name, currency, country, acctype, guava_id string // Entities
var account_number int64
//this is just for testing
var initialbalance float64
var err error
if len(args) != 6 {
return nil, error... | func CreateNewAccount(addr string, w http.ResponseWriter) {
localTestNet := GetLocalTestNetClient()
urlForCreateAccount := localTestNet.URL + "/friendbot?addr="
fmt.Fprintln(w, "Create URL is: ", urlForCreateAccount)
resp, err := http.Get(urlForCreateAccount + addr)
//resp, err := http.Get("https://horizon-testnet... | func (transaction *Transaction) create(srcAccountId string, destAccountId string, amount float32) *Transaction {
fmt.Println("creating transaction")
transaction.srcAccountId = srcAccountId
transaction.destAccountId = destAccountId
transaction.amount = amount
return transaction
} | func (b *Bittrex) Withdraw(currency string, quantity float64, address string, paymentID ...string) (JSONUUID, error) {
endPoint := "/account/withdraw?apikey=" + string(b.Key) + "¤cy=" + currency + "&quantity=" + strconv.FormatFloat(quantity, 'f', -1, 64) + "&address=" + address
if len(paymentID) > 0 {
endPoi... | func NewCoin(whole int64, fractional int64,
ticker string) Coin {
return Coin{
Whole: whole,
Fractional: fractional,
Ticker: ticker,
}
} | func walletCreate(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
logger.Info("API request made to create a wallet")
seed := r.FormValue("seed")
w1 := Wg.CreateWallet(seed) //use seed!
iw := wallet.NewReadableWallet(w1)
if iw != nil {
if err := Wg.SaveWall... | func newTx(t *testing.T, nonce, totalAmount, fee uint64) *types.Transaction {
inner := types.InnerTransaction{
AccountNonce: nonce,
Recipient: types.Address{},
Amount: totalAmount - fee,
GasLimit: 3,
Fee: fee,
}
buf, err := types.InterfaceToBytes(&inner)
require.NoError(t, err)
tx... | func NewAccount() *Account {
return &Account{
Id: 0,
Name: "",
State: StateEx_initialized | StateEx_bad | StateEx_sad,
Wallet: *NewBalance(),
Asset: nil,
Orders: make([]Order, 0),
}
} | func NewTransaction(from *wallet.Wallet, to string, amount int, chain *BlockChain) *Transaction {
var inputs []TxInput
var outputs []TxOutput
pubKeyHash := wallet.PublicKeyHash(from.PublicKey)
acc, validOutputs := chain.FindSpendableOutputs(pubKeyHash, amount)
if acc < amount {
log.Panic("Error: Not enough fun... | func NewAccount(privateKey []byte, publicKey *crypto.PublicKey) (*Account, error) {
contract, err := contract.CreateStandardContract(publicKey)
if err != nil {
return nil, err
}
programHash := contract.ToProgramHash()
address, err := programHash.ToAddress()
if err != nil {
return nil, err
}
return &Accou... | func (w *Wallet) CreateTransaction(bc *Blockchain) *Transaction {
input := Input{
address: w.PublicKey(),
value: w.findValue(bc),
}
t := &Transaction{
outputs: []Output{},
input: input,
}
return t
} | func (g *Generator) CreateSpendTx(spend *SpendableOut, fee ndrutil.Amount) *wire.MsgTx {
spendTx := wire.NewMsgTx()
spendTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: spend.prevOut,
Sequence: wire.MaxTxInSequenceNum,
ValueIn: int64(spend.amount),
BlockHeight: spend.blockHeight,
BlockIndex: ... | func New(nonce uint64, to string, amount, gasPrice *fixed.Number, gasLimit *big.Int, data []byte) *Tx {
var recpoint *[20]byte
if to != "" {
var recipient [20]byte
to = strings.TrimPrefix(to, "0x")
toBytes, _ := hex.DecodeString(to)
copy(recipient[:], toBytes)
recpoint = &recipient
}
tx := &Tx{
A... | func CreateAccount(vault *vault.Vault, bmAddr, name, organisation, server, token string) {
fmt.Printf("* Verifying if address is correct: ")
addr, err := address.New(bmAddr)
if err != nil {
fmt.Printf("not a valid address")
fmt.Println("")
os.Exit(1)
}
fmt.Printf("ok\n")
fmt.Printf("* Checking if address ... | func createAccount(dbe sqlExecutor, tableName string, acct *account.Account, feeAsset uint32, regAddr string) error {
stmt := fmt.Sprintf(internal.CreateAccount, tableName)
_, err := dbe.Exec(stmt, acct.ID, acct.PubKey.SerializeCompressed(), feeAsset, regAddr)
return err
} | func walletCreate(gateway *daemon.Gateway) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
logger.Info("API request made to create a wallet")
seed := r.FormValue("seed")
label := r.FormValue("label")
wltName := wallet.NewWalletFilename()
var wlt wallet.Wallet
var err error
// the... | func (eostx *EosTX) CreateAccountTx(userAccount, userPubkey string, balance int64, frozenTime int64, needVote bool, blockMap map[int]int64) (string, error) {
if strings.HasPrefix(userPubkey, "YTA") {
userPubkey = fmt.Sprintf("%s%s", "EOS", strings.TrimLeft(userPubkey, "YTA"))
}
eostx.API.SetCustomGetRequiredKeys(f... | func accountCreate(stub shim.ChaincodeStubInterface, params []string) peer.Response {
if len(params) < 1 {
return shim.Error("incorrect number of parameters. expecting 1+")
}
code, err := ValidateTokenCode(params[0])
if err != nil {
return shim.Error(err.Error())
}
// validate available token
tb := NewToke... | func (w *Wallet) FundTransaction(id string, amount types.Currency) (t types.Transaction, err error) {
counter := w.mu.Lock()
defer w.mu.Unlock(counter)
// Create a parent transaction and supply it with enough inputs to cover
// 'amount'.
parentTxn := types.Transaction{}
fundingOutputs, fundingTotal, err := w.fin... | func createbankacct(db *sql.DB) {
var givenuniqname string
fmt.Println("Please enter your uniqname")
fmt.Scan(&givenuniqname)
acctnumber := getacctnum()
acctbalance := 0
var accttype string
fmt.Println("Let's name this piggy! What is this account for? ex. 'checking'")
fmt.Scan(&accttype)
sqlStatement := `IN... | func (m *miningHarness) CreateCoinbaseTx(blockHeight int64, numOutputs uint32) (*dcrutil.Tx, error) {
// Create standard coinbase script.
extraNonce := int64(0)
coinbaseScript, err := txscript.NewScriptBuilder().
AddInt64(blockHeight).AddInt64(extraNonce).Script()
if err != nil {
return nil, err
}
tx := wire... | func FundAccount(address string, quarkAmount uint) (hash string, err error) {
if quarkAmount < minFundQuarks || quarkAmount > maxQuarks {
return "", ErrInvalidFundAmount
}
url := fmt.Sprintf("%s/fund?addr=%s&amount=%d.%d", friendbotURL, address, quarkAmount/quarksPerKin, quarkAmount%quarksPerKin)
resp, err := ht... | func TransactionCreate(creditAccountId, debitAccountId, description, clients, date, amount string) error {
var err error
now := time.Now()
_, err = database.SQL.Exec(`
INSERT INTO transactions (
credit_account_id, debit_account_id, amount, date, description, clients, created_at, updated_at
)
VALUES (?... | func NewTransaction(w *wallet.Wallet, to string, amount int, utxo *UTXOSet) *Transaction {
defer HandlePanic()
var inputs []TxInput
var outputs []TxOutput
pubKeyHash := wallet.PublicKeyHash(w.PublicKey)
acc, validOutputs := utxo.FindSpendableOutputs(pubKeyHash, amount)
if acc < amount {
log.Panic("Error: not ... | func CoinbaseTx(to, data string) *Transaction {
if data == "" {
//make a new data
data = fmt.Sprintf("Coins to %s", to)
}
//define the Transaction input and output for this Coinbase
txin := TxInput{
ID: []byte{}, //is nill because is referencing no output
Out: -1, //-1 because is referencing no outp... | func (facade *BranchManagerFacade) createTransaction(srcAccountId string, destAccountId string, amount float32) *Transaction {
var transaction = facade.transaction.create(srcAccountId, destAccountId, amount)
return transaction
} | func (be *AssetBackend) baseCoin(coinID []byte, contractData []byte) (*baseCoin, error) {
txHash, err := dexeth.DecodeCoinID(coinID)
if err != nil {
return nil, err
}
tx, _, err := be.node.transaction(be.ctx, txHash)
if err != nil {
if errors.Is(err, ethereum.NotFound) {
return nil, asset.CoinNotFoundError
... | func (dc *DagChain) CreateTx(privKey ecdsa.PrivateKey, income [32]byte, sender, receiver string, senderNo, receiverNo int, value int) *Transaction {
var validateRef [2][32]byte
verification := false
//index, vTips := dc.SelectTips()
_, vTips := dc.SelectTips(senderNo)
for dc.VerifyTips(vTips) == false {
_, vTip... | func NewBankTransferCreateRequest(idempotencyKey string, accessToken string, accountId string, type_ BankTransferType, network BankTransferNetwork, amount string, isoCurrencyCode string, description string, user BankTransferUser) *BankTransferCreateRequest {
this := BankTransferCreateRequest{}
this.IdempotencyKey = i... | func NewAccount(owner string) *Account{
account := Account{owner: owner, balance: 0}
return &account // return address, new object.
} | func (a *PlaidApiService) BankTransferCreate(ctx _context.Context) ApiBankTransferCreateRequest {
return ApiBankTransferCreateRequest{
ApiService: a,
ctx: ctx,
}
} | func NewAccount(addr string, tx *models.Transaction, _type int, txCount uint64) {
a := &models.Account{
Address: addr,
Vname: addr, //todo: get vname
Balance: "0",
TxCount: txCount,
FirstBlock: tx.BlockNumber,
LastBlock: tx.BlockNumber,
TokenAmount: "0",
TokenA... | func createTxOut(inCoin int64, addr btcutil.Address) *btcwire.TxOut {
// Pay the minimum network fee so that nodes will broadcast the tx.
outCoin := inCoin - 10000
// Take the address and generate a PubKeyScript out of it
script, err := btcscript.PayToAddrScript(addr)
if err != nil {
log.Fatal(err)
}
txout := ... | func (_MultiSigWalletFactoryContract *MultiSigWalletFactoryContractTransactor) Create(opts *bind.TransactOpts, _owners []common.Address, _required *big.Int) (*types.Transaction, error) {
return _MultiSigWalletFactoryContract.contract.Transact(opts, "create", _owners, _required)
} | func Transfer(toAddress string, amount string,ctx context.Context) (error) {
cfg, err := config.GetConfig()
if err != nil {
return err
}
client := ctx.Value(tellorCommon.ClientContextKey).(rpc.ETHClient)
privateKey, err := crypto.HexToECDSA(cfg.PrivateKey)
if err != nil {
return err
}
publicKey := private... | func (t *SimpleChaincode) createAccount(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
fmt.Println("Creating account")
// Obtain the username to associate with the account
if len(args) != 1 {
fmt.Println("Error obtaining username")
return nil, errors.New("createAccount accepts a single usern... | func NewCoinbaseTX(to, data string) *Transaction {
if data == "" {
data = fmt.Sprintf("Reward to '%s", to)
}
txin := TXInput{
Txid: []byte{},
Vout: -1,
ScriptSig: data,
}
txout := TXOutput{
Value: subsidy,
ScriptPubKey: to,
}
tx := Transaction{
ID: nil,
Vin: []TXInput{txin}... | func (s *Sender) Create(code []byte, value *Int) (Address, error) {
opts := CallOpts{From: s.Addr, GasPrice: &s.GasPrice, Value: value}
opts.Data = Data(code)
gas, err := s.EstimateGas(&opts)
if err != nil {
return Address{}, err
}
opts.Gas = s.pad(&gas)
h, err := s.Call(&opts)
if err != nil {
return Addres... | func (w *wallet) CreateAccount(ctx context.Context, name string, passphrase []byte) (e2wtypes.Account, error) {
if name == "" {
return nil, errors.New("account name missing")
}
if strings.HasPrefix(name, "_") {
return nil, fmt.Errorf("invalid account name %q", name)
}
if !w.unlocked {
return nil, errors.New(... | func (c *Client) CreateAccount(creator string, name string, fee int64, ownerPubKey, activePubKey, postingPubKey, memoPubKey string, jsonMeta string) error {
operation := &types.AccountCreateOperation{
Fee: types.NewSteemAsset(fee),
Creator: creator,
NewAccountName: name,
Owner: pubK... | func CreateWallet(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
logger.Debug("Entering Create Loyalty wallet ")
if len(args) != 3 {
return nil, errors.New("Incorrect number of arguments. Expecting name, password, points")
}
var userWallet LoyaltyPointWallet
userWallet.Name = args[0]
userW... | func NewTx(ctx context.Context, client *ethclient.Client, fromAddress string, toAddress string, value *big.Int) (*types.Transaction, error) {
nonce, err := client.PendingNonceAt(ctx, common.HexToAddress(fromAddress))
if err != nil {
return nil, err
}
gasPrice, err := GasPrice(ctx, client)
if err != nil {
retur... | func newWallet(c *cli.Context) (err error) {
s := []byte(c.Args().First())
//Generate secp256k1 private key
h1 := sha3.Sum256(s)
h2 := sha3.Sum256(h1[:])
private := h2[:]
fmt.Printf("Secp256k1 private key in hexadecimal is : %X\n", h2)
//WIF private key
k := append([]byte{0x80}, private...)
hk := sha2(k)
key... | func NewAccount(owner string) *Account {
account := Account{owner: owner, balance: 0}
return &account // 복사본 말고 원본 리턴(주소값)
} | func NewAccount() *Account { return &Account{} } | func NewTransaction(from, to string, amt int, bc *Blockchain) *Transaction {
var inputs []TXInput
var outputs []TXOutput
wallets := GetWallets()
wallet := wallets.GetWallet(from)
pubKeyHash := HashPubKey(wallet.PubKey)
total, validOutputs := bc.FindSpendableOutputs(pubKeyHash, amt)
if total < amt {
log.Panic... | func (client *Client) CreateMultiSigAccount(creator, newAccountName, fee string, accountOwners []string, keyOwners []string,
threshold uint32) (*OperResp, error) {
err := ValidateNameAccount(newAccountName)
if err != nil {
return nil, err
}
validate := ValidateFee(fee, config.MIN_ACCOUNT_CREATION_FEE)
if valida... | func constructUnsignedTransaction(
previousTransactionHashHex string,
previousOutputIndex uint32,
previousOutputValue int64,
feePerVbyte int64,
recipientAddresses []string,
chainParams *chaincfg.Params,
) (*wire.MsgTx, error) {
// If the previous output transaction hash is passed as a []byte, can use
// chainha... | func GenerateCoinKey() (sdk.Address, string, error) {
// construct an in-memory key store
codec, err := words.LoadCodec("english")
if err != nil {
return nil, "", err
}
keybase := keys.New(
dbm.NewMemDB(),
codec,
)
// generate a private key, with recovery phrase
info, secret, err := keybase.Create("name"... | func walletCreateND(name string) error {
_, err := nd.CreateWallet(name, store, keystorev4.New())
return err
} | func NewTransaction(accountFrom *Account, amount float64, pixKeyTo *PixKey, description string, id string) (*Transaction, error) {
transaction := Transaction{
AccountFrom: accountFrom,
AccountFromID: accountFrom.ID,
Amount: amount,
PixKeyTo: pixKeyTo,
PixKeyToID: pixKeyTo.ID,
Status: ... | func (w *Wallet) NewAccount(name string) (uint32, error) {
return w.accountManager.new(bip44AccountCreateOptions{
name: name,
seed: w.Seed(),
seedPassphrase: w.SeedPassphrase(),
coinType: w.Coin(),
bip44CoinType: w.Bip44Coin(),
})
} | func (c *blockGenerator) constructCoinbaseTx(rewardReceiver *key.PublicKey, proof []byte, score []byte) (*transactions.Coinbase, error) {
// The rewards for both the Generator and the Provisioners are disclosed.
// Provisioner reward addresses do not require obfuscation
// The Generator address rewards do.
// Cons... | func (dcr *Backend) FundingCoin(ctx context.Context, coinID []byte, redeemScript []byte) (asset.FundingCoin, error) {
txHash, vout, err := decodeCoinID(coinID)
if err != nil {
return nil, fmt.Errorf("error decoding coin ID %x: %w", coinID, err)
}
utxo, err := dcr.utxo(ctx, txHash, vout, redeemScript)
if err != n... | func (s *Statedb) CreateAccount(address common.Address) {
if object := s.getStateObject(address); object == nil {
object = newStateObject(address)
s.curJournal.append(createObjectChange{&address})
s.stateObjects[address] = object
}
} | func (c *Client) Create(country, baseCurrency, bankID, bankIDCode, bic, iban string) (a *Account, err error) {
account := &Account{
Country: country,
BaseCurrency: baseCurrency,
BankID: bankID,
BankIDCode: bankIDCode,
BIC: bic,
IBAN: iban,
}
return c.CreateEx(account)
} | func newTransaction(btc *Backend, txHash, blockHash, lastLookup *chainhash.Hash,
blockHeight int64, isCoinbase bool, ins []txIn, outs []txOut, feeRate uint64) *Tx {
// Set a nil blockHash to the zero hash.
hash := blockHash
if hash == nil {
hash = &zeroHash
}
return &Tx{
btc: btc,
blockHash: *hash,
... | func (t *TrackerImp) CreateAccount(address string) error {
t.mu.Lock()
defer t.mu.Unlock()
if !common.IsHexAddress(address) {
return ErrInvalidAddress
}
nonce, err := t.pendingNonceAt(address)
if err != nil {
return err
}
return t.storer.createAccountIfNotExists(address, nonce)
} | func (node *Node) CreateTransactionForEnterMethod(amount int64, priKey string) error {
var err error
toAddress := node.DemoContractAddress
abi, err := abi.JSON(strings.NewReader(contracts.LotteryABI))
if err != nil {
utils.GetLogInstance().Error("Failed to generate staking contract's ABI", "error", err)
return... | func createSpendingTx(prevTx *bchutil.Tx, index uint32, scriptSig []byte, address bchutil.Address) (*bchutil.Tx, error) {
scriptPubKey, err := txscript.PayToAddrScript(address)
if err != nil {
return nil, err
}
prevTxMsg := prevTx.MsgTx()
prevOut := prevTxMsg.TxOut[index]
prevOutPoint := &wire.OutPoint{Hash: p... | func CreateWallet(se Servicer) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
rlt := &pp.EmptyRes{}
for {
// get coin type
cp := r.FormValue("type")
// get seed
sd := r.FormValue("seed")
if sd == "" {
rlt = pp.MakeErrRes(errors.New("seed is requir... | func CreateAccount() *Account {
key, _ := crypto.GenerateKey()
addr := crypto.PubkeyToAddress(key.PublicKey)
return &Account{
Key: key,
Addr: addr,
}
} | func CreateRawTransaction(sendTo string, amount uint64, Fee ltcutil.Amount, client *rpcclient.Client, PrivateKey string, userId uint64) *chainhash.Hash {
var addressMap = make(map[string]uint64)
currentTime := int64(0)
inputs,addressMap, ColdKey, PrivateKeyCMP := CreateInputs(client, userId, amount, PrivateKey)
if... | func NewFund(i float64) *Fund {
return &Fund{
balance: i,
}
} | [
"0.8088337",
"0.6728707",
"0.6579178",
"0.65382123",
"0.64733255",
"0.6306525",
"0.62969047",
"0.61604756",
"0.615635",
"0.61109287",
"0.61049384",
"0.60896677",
"0.60533875",
"0.60533875",
"0.60111797",
"0.5954883",
"0.5954526",
"0.59530544",
"0.5938386",
"0.59177023",
"0.59... |
decodeTokenFundingCoin decodes a byte slice into an tokenFundingCoinID. | func decodeTokenFundingCoin(coinID []byte) (*tokenFundingCoin, error) {
if len(coinID) != tokenFundingCoinIDSize {
return nil, fmt.Errorf("decodeTokenFundingCoin: length expected %v, got %v",
tokenFundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &tokenFundingCoin{
... | func decodeFundingCoinID(coinID []byte) (*fundingCoinID, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoinID: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoinID{
Address: address,
A... | func decodeFundingCoin(coinID []byte) (*fundingCoin, error) {
if len(coinID) != fundingCoinIDSize {
return nil, fmt.Errorf("decodeFundingCoin: length expected %v, got %v",
fundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &fundingCoin{
addr: address,
amt: binary... | func decodeCoinID(coinID []byte) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func decodeCoinID(coinID dex.Bytes) (*chainhash.Hash, uint32, error) {
if len(coinID) != 36 {
return nil, 0, fmt.Errorf("coin ID wrong length. expected 36, got %d", len(coinID))
}
var txHash chainhash.Hash
copy(txHash[:], coinID[:32])
return &txHash, binary.BigEndian.Uint32(coinID[32:]), nil
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func DecodeCoinID(coinID []byte) (common.Hash, error) {
if len(coinID) != common.HashLength {
return common.Hash{}, fmt.Errorf("wrong coin ID length. wanted %d, got %d",
common.HashLength, len(coinID))
}
var h common.Hash
h.SetBytes(coinID)
return h, nil
} | func decodeAccountBalanceTo(enc []byte, to *uint256.Int) error {
to.Clear()
if len(enc) == 0 {
return nil
}
var fieldSet = enc[0]
// if an account has 0 balance...
if fieldSet&2 <= 0 {
return nil
}
var pos = 1
if fieldSet&1 > 0 {
decodeLength := int(enc[pos])
if len(enc) < pos+decodeLength+1 {
... | func (_Token *TokenSession) DecodeTradeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeTradeAssetData(&_Token.CallOpts, _assetData)
} | func (_Token *TokenCallerSession) DecodeTradeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeTradeAssetData(&_Token.CallOpts, _assetData)
} | func Decode(friendCode string) uint64 {
if len(friendCode) != 10 {
return 0
}
friendCode = "AAAA-" + friendCode
return steamID(friendCode)
} | func (_Token *TokenCaller) DecodeTradeAssetData(opts *bind.CallOpts, _assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
ret := new(struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds ... | func DecodeToken(i string, prvSrc *PrivateKey) (t Token, err error) {
// Base64 decode
var b []byte
if b, err = b64.DecodeString(i); err != nil {
return
}
// Unmarshal
var msg EncryptedMessage
if err = json.Unmarshal(b, &msg); err != nil {
return
}
// Decrypt message
if t, err = msg.Decrypt(prvSrc); err... | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
txid, vout, err := decodeCoinID(coinID)
if err != nil {
return "", err
}
return fmt.Sprintf("%v:%d", txid, vout), err
} | func UA_ChannelSecurityToken_decodeBinary(src []UA_ByteString, offset []uint, dst []UA_ChannelSecurityToken) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[66]))[:], 0, nil)
} | func UA_UserIdentityToken_decodeBinary(src []UA_ByteString, offset []uint, dst []UA_UserIdentityToken) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[67]))[:], 0, nil)
} | func (logic *Logic) DecodeToken(token []byte) (*auth.Token, error) {
logic.keyConfigLock.RLock()
defer logic.keyConfigLock.RUnlock()
return auth.ParseToken(token, logic.pubKeys.Keys)
} | func (d *Driver) DecodeCoinID(coinID []byte) (string, error) {
// Dogecoin and Bitcoin have the same tx hash and output format.
return (&btc.Driver{}).DecodeCoinID(coinID)
} | func createTokenFundingCoin(address common.Address, tokenValue, fees uint64) *tokenFundingCoin {
return &tokenFundingCoin{
addr: address,
amt: tokenValue,
fees: fees,
}
} | func decode(dst, src []byte) int | func DecodeBitcoin() {
for Private, keys := range PrivateKeys {
PublicKeys[Private] = keys
}
} | func (f *fund) Deserialize(data []byte) error {
gen := rewardingpb.Fund{}
if err := proto.Unmarshal(data, &gen); err != nil {
return err
}
totalBalance, ok := new(big.Int).SetString(gen.TotalBalance, 10)
if !ok {
return errors.New("failed to set total balance")
}
unclaimedBalance, ok := new(big.Int).SetStrin... | func (_Token *TokenCallerSession) DecodeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeAssetData(&_Token.CallOpts, _assetData)
} | func DecodeUint256(s string) (*big.Int, error) {
return hexutil.DecodeBig(s)
} | func (_Token *TokenCallerSession) UnpackTokenId(_tokenId *big.Int) (struct {
Market common.Address
Price *big.Int
Outcome uint8
Type uint8
}, error) {
return _Token.Contract.UnpackTokenId(&_Token.CallOpts, _tokenId)
} | func (_Token *TokenSession) DecodeAssetData(_assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
return _Token.Contract.DecodeAssetData(&_Token.CallOpts, _assetData)
} | func decodeFuncSign(data []byte) string {
funcSign := hexutil.Encode(data[:funcSingatureBytes]) //The function signature is first 4 bytes of data in ethereum
return funcSign
} | func (cb *codedReader) decodeFixed32() (x uint64, err error) {
// x, err already 0
i := cb.index + 4
if i < 0 || i > len(cb.buf) {
err = io.ErrUnexpectedEOF
return
}
cb.index = i
x = uint64(cb.buf[i-4])
x |= uint64(cb.buf[i-3]) << 8
x |= uint64(cb.buf[i-2]) << 16
x |= uint64(cb.buf[i-1]) << 24
return
} | func tokenDecode(token string) ([]byte, error) {
return util.TokenDecode(util.TokenTypeTstore, token)
} | func BenchmarkDecodeToken(b *testing.B) {
for i := uint(9); i < 16; i++ {
n := 1 << i
name := fmt.Sprintf("bytes=%d (2^%d)", n, i)
b.Run(name, benchmarkDecodeTokenOfLength(n))
}
} | func UA_UserNameIdentityToken_decodeBinary(src []UA_ByteString, offset []uint, dst []UA_UserNameIdentityToken) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[98]))[:], 0, nil)
} | func TransactionUnpack([]byte) Transaction { panic("") } | func decryptToken(getToken string) int64 {
token, _ := jwt.Parse(getToken, func(token *jwt.Token) (interface{}, error) {
// Don't forget to validate the alg is what you expect:
if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
... | func TransactionIDFromBytes(bytes []byte) (transactionID TransactionID, consumedBytes int, err error) {
marshalUtil := marshalutil.New(bytes)
if transactionID, err = TransactionIDFromMarshalUtil(marshalUtil); err != nil {
err = errors.Errorf("failed to parse TransactionID from MarshalUtil: %w", err)
return
}
co... | func (pkt *SubDelNotify) Decode(bytes []byte) (err error) {
var used int
offset := 4 // header
qidCount, used, err := XdrGetUint32(bytes[offset:])
if err != nil {
return err
}
offset += used
for i := uint32(0); i < qidCount; i++ {
pkt.QuenchIDs[i], used, err = XdrGetInt64(bytes[offset:])
if err != nil {
... | func BitcoinCheckDecode(src string) ([]byte, string, error) {
dst, err := CheckDecodeString(src)
if err != nil {
return nil, "", err
}
prefix, err := getPrefix(dst)
if err != nil {
// If prefix is unrecognized, assume it's the first byte.
prefix = dst[0:1]
}
h := hex.EncodeToString(prefix)
length, found :... | func (_Token *TokenSession) UnpackTokenId(_tokenId *big.Int) (struct {
Market common.Address
Price *big.Int
Outcome uint8
Type uint8
}, error) {
return _Token.Contract.UnpackTokenId(&_Token.CallOpts, _tokenId)
} | func benchmarkDecodeTokenOfLength(bytes int) func(*testing.B) {
runBenchmark := func(b *testing.B) {
b.StopTimer()
keyID := "keyID"
encodedToken, publicKey := generateTokenOfLength(bytes, keyID)
application := makeApplicationWithKey(keyID, publicKey)
b.StartTimer()
for i := 0; i < b.N; i++ {
application... | func (r *Ring) Decrypt(dst, src []byte) ([]byte, error) {
if len(src) < epochSize {
return dst, ErrBadToken
}
epoch := binary.LittleEndian.Uint32(src)
mac, ok := r.registry[epoch]
if !ok {
return dst, ErrUnknownEpoch
}
return mac.Decrypt(dst, src)
} | func (c *Client) DecodeTransaction(txHex string) (txInfo *TxInfo, err error) {
// Start the post data
postData := []byte(fmt.Sprintf(`{"txhex":"%s"}`, txHex))
var resp string
// https://api.whatsonchain.com/v1/bsv/<network>/tx/decode
if resp, err = c.request(fmt.Sprintf("%s%s/tx/decode", apiEndpoint, c.Ne... | func decodeStakeCall(getData []byte) int64 {
value := new(big.Int)
value.SetBytes(getData[funcSingatureBytes:]) //Escape the method call.
return value.Int64()
} | func Decode(p []byte) ([]byte, error) {
data, err := Decode6b4b(p)
if len(data) == 0 {
err = fmt.Errorf("empty packet")
}
if err != nil {
return data, err
}
last := len(data) - 1
pktCRC := data[last]
data = data[:last] // without CRC
calcCRC := CRC8(data)
if calcCRC != pktCRC {
err = fmt.Errorf("compute... | func Decode(dst *SubnetworkID, src string) error {
// Return error if ID string is too long.
if len(src) > MaxStringSize {
return ErrIDStrSize
}
// Hex decoder expects the ID to be a multiple of two. When not, pad
// with a leading zero.
var srcBytes []byte
if len(src)%2 == 0 {
srcBytes = []byte(src)
} els... | func Decode(s string) []byte {
revstr := string(Reverse([]byte(s)))
ret := big.NewInt(0)
radix := big.NewInt(1)
fiftyEight := big.NewInt(58)
// Convert base58string to bigint
for _, b := range revstr {
radix2 := new(big.Int).Set(radix)
for j, c := range BitcoinBase58Strings {
if b == c {
ret.Add(ret, r... | func (_Token *TokenCaller) UnpackTokenId(opts *bind.CallOpts, _tokenId *big.Int) (struct {
Market common.Address
Price *big.Int
Outcome uint8
Type uint8
}, error) {
ret := new(struct {
Market common.Address
Price *big.Int
Outcome uint8
Type uint8
})
out := ret
err := _Token.contract.Call(opt... | func decodeProcessedTransaction(ptBytes []byte, pt *modules.ProcessedTransaction) error {
err := encoding.Unmarshal(ptBytes, pt)
return err
} | func decodeTokenName(tokenID string) (string, string, error) {
ss := strings.Split(tokenID, ":")
if len(ss) != 2 {
return "", "", status.Errorf(codes.InvalidArgument, "token format invalid")
}
b, err := base64.RawURLEncoding.DecodeString(ss[1])
if err != nil {
return "", "", status.Errorf(codes.InvalidArgument... | func (v *Vault) decode(str string) error {
lines := strings.SplitN(str, "\n", 2)
if strings.TrimSpace(lines[0]) != HEADER {
return errors.New("Invalid vault file format")
}
// Concat all lines
content := strings.TrimSpace(lines[1])
content = strings.Replace(content, "\r", "", -1)
content = strings.Replace(co... | func PeerIDFromBytes(b []byte) PeerID {
if len(b) != 20 {
panic("peer ID must be 20 bytes")
}
var buf [20]byte
copy(buf[:], b)
return PeerID(buf)
} | func DecodeTrans(data []byte) *StTrans {
out := new(StTrans)
signLen := data[0]
if signLen <= 30 || signLen >= 250 {
return nil
}
out.Key = runtime.GetHash(data)
out.Sign = data[1 : signLen+1]
signData := data[signLen+1:]
n := runtime.Decode(signData, &out.TransactionHead)
out.Data = signData[n:]
rst := ... | func (pkt *QuenchDelRequest) Decode(bytes []byte) (err error) {
var used int
offset := 4 // header
pkt.XID, used, err = XdrGetUint32(bytes[offset:])
if err != nil {
return err
}
offset += used
pkt.QuenchID, used, err = XdrGetInt64(bytes[offset:])
if err != nil {
return err
}
offset += used
return nil
... | func TransactionsUnpack([]byte) Transactions { panic("") } | func (_Token *TokenCaller) DecodeAssetData(opts *bind.CallOpts, _assetData []byte) (struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*big.Int
TokenValues []*big.Int
CallbackData []byte
}, error) {
ret := new(struct {
AssetProxyId [4]byte
TokenAddress common.Address
TokenIds []*b... | func DecodeTransaction(b []byte) (*Transaction, error) {
version := binary.LittleEndian.Uint32(b[0:4])
b = b[4:]
txInArr := []*TxIn{}
txInCount, err := common.DecodeVarInt(b)
if err != nil {
return nil, err
}
b = b[len(txInCount.Encode()):]
for i := 0; uint64(i) < txInCount.Data; i++ {
txIn, err := DecodeT... | func UA_SignatureData_decodeBinary(src []UA_ByteString, offset []uint, dst []UA_SignatureData) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[68]))[:], 0, nil)
} | func Decode(data []byte) (uuid UUID, err error) {
const encodedUUIDLen = 36
if len(data) != encodedUUIDLen {
err = errors.New("invalid UUID data")
return
}
_ = data[encodedUUIDLen-1]
if data[8] != '-' || data[13] != '-' || data[18] != '-' || data[23] != '-' {
err = errors.New("invalid UUID data")
return
}... | func (r *V1Service) DecodeIntegrityToken(packageName string, decodeintegritytokenrequest *DecodeIntegrityTokenRequest) *V1DecodeIntegrityTokenCall {
c := &V1DecodeIntegrityTokenCall{s: r.s, urlParams_: make(gensupport.URLParams)}
c.packageName = packageName
c.decodeintegritytokenrequest = decodeintegritytokenrequest... | func decode(src []byte) (traceID []byte, spanID uint64, opts byte, ok bool) {
if len(src) < Len {
return traceID, spanID, 0, false
}
var offset = 0
readByte := func() byte { b := src[offset]; offset++; return b }
readUint64 := func() uint64 { v := binary.LittleEndian.Uint64(src[offset:]); offset += 8; return v }... | func decodeUUIDBinary(src []byte) ([]byte, error) {
if len(src) != 16 {
return nil, fmt.Errorf("pq: unable to decode uuid; bad length: %d", len(src))
}
dst := make([]byte, 36)
dst[8], dst[13], dst[18], dst[23] = '-', '-', '-', '-'
hex.Encode(dst[0:], src[0:4])
hex.Encode(dst[9:], src[4:6])
hex.Encode(dst[14:]... | func (b base62URLIDEncoder) Decode(str string) (uint64, error) {
var id uint64
for i, symbol := range str {
pos := strings.IndexRune(base62Chars, symbol)
if pos == -1 {
return 0, fmt.Errorf("invalid base62 character: %s", string(symbol))
}
id += uint64(pos) * uint64(math.Pow(float64(base62CharsCount), fl... | func Decode(encoded string) (uint32, error) {
if len(encoded) != 51 {
return 0, errors.New("invalid encoded string")
}
var id uint32
for i := 0; i < len(encoded); i++ {
id = id*uint32(base) + uint31(strings.IndexByte(space, encoded[i]))
}
return id, nil
} | func decodeNodeID(nodeIDBytes []byte) (*storage.NodeID, error) {
var nodeIdProto storage.NodeIDProto
if err := proto.Unmarshal(nodeIDBytes, &nodeIdProto); err != nil {
glog.Warningf("Failed to decode nodeid: %s", err)
return nil, err
}
return storage.NewNodeIDFromProto(nodeIdProto), nil
} | func (u *UUID) decodeURN(t []byte) (err error) {
// t[:9] is urnUUIDPrefix
if !bytes.Equal(t[:9], urnPrefix) {
return errors.Wrap(ErrUUIDFormat, string(t))
}
return u.decodePlain(t[9:])
} | func (c Chain) DecodeID() ([]byte, error) {
return hex.DecodeString(c.ID)
} | func decode(encryptedB64 string) (stellar1.EncryptedAccountBundle, stellar1.Hash, error) {
cipherpack, err := base64.StdEncoding.DecodeString(encryptedB64)
if err != nil {
return stellar1.EncryptedAccountBundle{}, stellar1.Hash{}, err
}
encHash := sha256.Sum256(cipherpack)
var enc stellar1.EncryptedAccountBundle... | func (u *User) DecodeToken() (string, error) {
if u.BareToken == "" {
return "", errors.New("Provided token is empty...")
}
// Decrypt
var CipherNumber int
if u.IsPublic {
CipherNumber = PublicKeyCipherNumber
} else {
CipherNumber = SecretKeyCipherNumber
}
plaintext := caesar.DecryptCiphertext(u.BareToke... | func DecodeSignature(sig string) (r, s *big.Int, err error) {
values := strings.Split(sig, "|")
if len(values) != 2 {
return r, s, fmt.Errorf("wrong number of values in signature: got %d, want 2", len(values))
}
r, _ = new(big.Int).SetString(values[0], 36)
s, _ = new(big.Int).SetString(values[1], 36)
return r, ... | func DecodeToken(v interface{}, key []byte, token string) (reterr error) {
// Just in case, stranger shit has happened...
// (I've seen some inputs that cause decryption to panic, maybe I imagined it or it was a case that doesn't
// apply here, but regardless I think it's better to have this than not.)
defer func(... | func (omci *DeleteResponse) DecodeFromBytes(data []byte, p gopacket.PacketBuilder) error {
// Common ClassID/EntityID decode in msgBase
err := omci.MeBasePacket.DecodeFromBytes(data, p)
if err != nil {
return err
}
entity, omciErr := me.LoadManagedEntityDefinition(omci.EntityClass,
me.ParamData{EntityID: omci.... | func (d Decoder) decodeUint(v []byte) (schema.Uint, error) {
if i, e := strconv.ParseUint(string(v), 10, 64); e != nil {
return 0, e
} else {
return schema.Uint(i), nil
}
} | func decodeSignature(sig string) (string, error) {
decBytes, err := base58check.Decode(sig)
if err != nil {
return "", errors.Wrap(err, "failed to decode signature")
}
return hex.EncodeToString(decBytes), nil
} | func decodeSignedEthereumTxResponse(_ context.Context, reply interface{}) (interface{}, error) {
resp, ok := reply.(*pb.SignedEthereumTxReply)
if !ok {
e := fmt.Errorf("pb SignedEthereumTxReply type assertion error")
return endpoint1.SignedEthereumTxResponse{Err: e}, e
}
return endpoint1.SignedEthereumTxRespons... | func (j *JoinRequestPayload) decode(buffer []byte, pos *int) error {
if buffer == nil || pos == nil {
return ErrNilError
}
if len(buffer) < (*pos + 18) {
return ErrBufferTruncated
}
j.AppEUI = EUIFromUint64(binary.LittleEndian.Uint64(buffer[*pos:]))
*pos += 8
j.DevEUI = EUIFromUint64(binary.LittleEndian.Uint... | func decodeGrpcGetAccountRequest(ctx context.Context, r interface{}) (interface{}, error) {
req := r.(*pb.GetAccountRequest)
return req.ID, nil
} | func DecodeToken(token string) ([]byte, error) {
return common.DecodeToken(token, serverJWKs)
} | func ContractIDFromBytes(data []byte) (ContractID, error) {
pb := services.ContractID{}
err := protobuf.Unmarshal(data, &pb)
if err != nil {
return ContractID{}, err
}
return *_ContractIDFromProtobuf(&pb), nil
} | func byteSliceToDeck(deckBytes []byte) deck {
stringDeck := string(deckBytes)
return deck(strings.Split(stringDeck, ","))
} | func (c *tokenFundingCoin) ID() dex.Bytes {
return []byte(c.addr.String())
} | func Mydecode(p string) string {
decodeStr, _ := hex.DecodeString(p)
return string(decodeStr)
} | func Byte_decodeBinary(dst []UA_Byte, type_ []UA_DataType, ctx []Ctx) status {
if ctx[0].pos[1:] > ctx[0].end {
return status((UA_StatusCode((uint32_t((uint32((uint32(2147942400)))))))))
}
dst[0] = UA_Byte((uint8_t((__uint8_t((uint8((__uint8_t((uint8_t((UA_Byte((ctx[0].pos[0]))))))))))))))
ctx.pos = ctx[0].pos[1:... | func (c *ed448) UnmarshalByteSecret(s []byte) (d []byte) {
// Check prefixed size
if len(s) != ed448lib.SeedSize+1 {
return nil
}
// Strip prefix
return s[1:]
} | func decodeRaw31(raw []byte) uint32 {
var rv uint32
if b, ok := fourByte.Get().([]byte); ok {
topByte := maskOutTopBit(raw[0])
b[0] = topByte
k := 1
for _, v := range raw[1:4] {
b[k] = v
k++
}
rv = binary.BigEndian.Uint32(b)
fourByte.Put(b)
}
return rv
} | func createFundingCoinID(address common.Address, amount uint64) *fundingCoinID {
return &fundingCoinID{
Address: address,
Amount: amount,
}
} | func decodeObjectIdentifier(bytes []byte) (oid []uint32, ok bool) {
// Reserve a space as the first component is split.
oid = []uint32{0}
// Decode each component.
for len(bytes) != 0 {
var c uint32
var lengthOverride int
c, lengthOverride, bytes, ok = parseBase128(bytes)
if !ok || lengthOverride != 0 {
... | func Decode(dst, src []byte) (int, error) {
zeros := 0
for _, b := range src {
if b == base58alphabet[0] {
zeros++
} else {
break
}
}
big58 := big.NewInt(58)
i := big.NewInt(0)
for _, c := range src {
i.Mul(i, big58)
val := base58reverse[int(c)]
if val < 0 {
return 0, fmt.Errorf("Bad characte... | func Decode(rawToken string) (token Token, err error) {
payload, err := DecodePayloadAsRawJSON(rawToken)
if err != nil {
return token, err
}
if err := json.NewDecoder(bytes.NewReader(payload)).Decode(&token); err != nil {
return token, err
}
return token, nil
} | func TokenForTraceID(b []byte) uint32 {
h := fnv.New32()
_, _ = h.Write(b)
return h.Sum32()
} | func GetBorrowAccruedIDFromBytes(bz []byte) uint64 {
return binary.BigEndian.Uint64(bz)
} | func ParseBytes(b []byte) (UUID, error) {
var uuid UUID
switch len(b) {
case 36: // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
case 36 + 9: // urn:uuid:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
if !bytes.Equal(bytes.ToLower(b[:9]), []byte("urn:uuid:")) {
return uuid, fmt.Errorf("invalid urn prefix: %q", b[:9])
}
b = ... | func (mb *relayPackager) Decode(adu []byte) (pdu *ProtocolDataUnit, err error) {
if len(adu) < 8 {
return nil, ErrReturnResult
}
length := len(adu)
if adu[7] != Sign(adu) {
err = fmt.Errorf("serial: response crc '%v' does not match expected '%v'", adu[7], Sign(adu))
return
}
// Function code & data
pdu = &... | func (q *Queue) decodeOffset(val event.Offset) (id, offset int64, err error) {
arr := strings.Split(string(val), "-")
if len(arr) == 2 {
id, err := strconv.ParseInt(arr[0], 10, 64)
if err != nil {
return 0, 0, err
}
offset, err := strconv.ParseInt(arr[1], 10, 64)
if err != nil {
return 0, 0, err
}
... | func Decode(data []byte) (Term, error) { return DecodeFrom(bytes.NewBuffer(data)) } | func IDFromToken(token string) (*api.Snowflake, error) {
strs := strings.Split(token, ".")
if len(strs) == 0 {
return nil, errors.New("BotToken is not in a valid format")
}
byteID, err := base64.StdEncoding.DecodeString(strs[0])
if err != nil {
return nil, err
}
strID := api.Snowflake(byteID)
return &strID,... | func (dec *fecDecoder) decodeBytes(data []byte) []byte {
seqid := binary.LittleEndian.Uint32(data)
index := seqid % dec.seqlen
if dec.seqs[index] == seqid {
return nil
}
dec.seqs[index] = seqid
return data[fecHeaderSize:]
} | func (d *BlockchainPendingDetails) Decode(r io.Reader, v uint32) error {
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
return json.Unmarshal(data, d)
} | func uint64FromByteKey(k []byte) uint64 {
return binary.BigEndian.Uint64(k)
} | func uint64FromByteKey(k []byte) uint64 {
return binary.BigEndian.Uint64(k)
} | func DecodeHex(data string, result interface{}) error {
if !strings.HasPrefix(data, HexPrefix) {
return fmt.Errorf(
"malformed hex without hex prefix: %q", data,
)
}
data = data[2:]
switch result := result.(type) {
case *big.Int:
_, success := result.SetString(data, 16)
if !success {
return fmt.Err... | func UA_SecurityTokenRequestType_decodeBinary(src []UA_ByteString, offset []uint, dst []int) UA_StatusCode {
return UA_decodeBinary(src, offset, dst, (*[100000000]UA_DataType)(unsafe.Pointer(&UA_TYPES[71]))[:], 0, nil)
} | func (d *GeneratedTxDetails) Decode(r io.Reader, v uint32) error {
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
return json.Unmarshal(data, d)
} | [
"0.75587547",
"0.74109536",
"0.6551182",
"0.6543139",
"0.5765304",
"0.5765304",
"0.5510699",
"0.5303154",
"0.5296912",
"0.52796704",
"0.5182376",
"0.5163258",
"0.5145577",
"0.5145577",
"0.51287365",
"0.510413",
"0.50984967",
"0.505249",
"0.5038786",
"0.50054485",
"0.50013936"... |
createTokenFundingCoin constructs a new tokenFundingCoin for the provided account address, value, and fees in gwei. | func createTokenFundingCoin(address common.Address, tokenValue, fees uint64) *tokenFundingCoin {
return &tokenFundingCoin{
addr: address,
amt: tokenValue,
fees: fees,
}
} | func createFundingCoin(address common.Address, amount uint64) *fundingCoin {
return &fundingCoin{
addr: address,
amt: amount,
}
} | func newTx(t *testing.T, nonce, totalAmount, fee uint64) *types.Transaction {
inner := types.InnerTransaction{
AccountNonce: nonce,
Recipient: types.Address{},
Amount: totalAmount - fee,
GasLimit: 3,
Fee: fee,
}
buf, err := types.InterfaceToBytes(&inner)
require.NoError(t, err)
tx... | func createFundingCoinID(address common.Address, amount uint64) *fundingCoinID {
return &fundingCoinID{
Address: address,
Amount: amount,
}
} | func createCoinbaseTx(params *blockchain.Params, coinbaseScript []byte, addr string) (*transaction.Tx, error) {
// Create the script to pay to the provided payment address if one was
// specified. Otherwise create a script that allows the coinbase to be
// redeemable by anyone.
var pkScript []byte
pkScript = []b... | func New(nonce uint64, to string, amount, gasPrice *fixed.Number, gasLimit *big.Int, data []byte) *Tx {
var recpoint *[20]byte
if to != "" {
var recipient [20]byte
to = strings.TrimPrefix(to, "0x")
toBytes, _ := hex.DecodeString(to)
copy(recipient[:], toBytes)
recpoint = &recipient
}
tx := &Tx{
A... | func (wlt *Wallet) CreateAndSignTransaction(
vld Validator,
unspent blockdb.UnspentGetter,
headTime uint64,
amt Balance,
dest cipher.Address) (*coin.Transaction, error) {
addrs := wlt.GetAddresses()
ok, err := vld.HasUnconfirmedSpendTx(addrs)
if err != nil {
return nil, fmt.Errorf("checking unconfirmed spend... | func NewTransaction(from, to string, amount int, bc *Blockchain) *Transaction {
wallets, err := NewWallets()
if err != nil {
log.Panic(err)
}
fromWallet := wallets.GetWallet(from)
avaiable := bc.FindSpendable(fromWallet)
if avaiable < amount {
log.Panic("ERROR: Not enough funds")
}
tx := Transaction{nil, ti... | func NewCoinbaseTX(to, data string) *Transaction {
if data == "" {
data = fmt.Sprintf("Reward to '%s", to)
}
txin := TXInput{
Txid: []byte{},
Vout: -1,
ScriptSig: data,
}
txout := TXOutput{
Value: subsidy,
ScriptPubKey: to,
}
tx := Transaction{
ID: nil,
Vin: []TXInput{txin}... | func CreateCoinbaseTx(totalReward float64, pk []byte, height int64) *model.Transaction {
tx := &model.Transaction{
Outputs: []*model.Output{{
Value: totalReward,
PublicKey: pk,
}},
Height: height,
}
// Ignore error because tx can never be nil.
FillTxHash(tx)
return tx
} | func (c *Client) CreateSendTokenTransaction(token Token, fromAccount SendableAccount, toAccount Account, amount int) *types.Transaction {
nonce, err := c.Ethclient.PendingNonceAt(context.Background(), fromAccount.Address)
if err != nil {
log.Fatal(err)
}
value := big.NewInt(0)
gasLimit := uint64(2000000)
gasP... | func (ms *MicroStellar) FundAccount(sourceSeed string, addressOrSeed string, amount string, options ...*Options) error {
if !ValidAddressOrSeed(sourceSeed) {
return ms.errorf("invalid source address or seed: %s", sourceSeed)
}
if !ValidAddressOrSeed(addressOrSeed) {
return ms.errorf("invalid target address or s... | func CreateTx(utxos []*Utxo, addresses []*PayToAddress,
opReturns []OpReturnData, privateKey *bsvec.PrivateKey) (*bt.Tx, error) {
// Start creating a new transaction
tx := bt.NewTx()
// Accumulate the total satoshis from all utxo(s)
var totalSatoshis uint64
// Loop all utxos and add to the transaction... | func constructCoinbaseTx(rewardReceiver *key.PublicKey, proof []byte, score []byte) (*transactions.Coinbase, error) {
// The rewards for both the Generator and the Provisioners are disclosed.
// Provisioner reward addresses do not require obfuscation
// The Generator address rewards do.
// Construct one-time addre... | func NewTransaction(from, to string, amt int, bc *Blockchain) *Transaction {
var inputs []TXInput
var outputs []TXOutput
wallets := GetWallets()
wallet := wallets.GetWallet(from)
pubKeyHash := HashPubKey(wallet.PubKey)
total, validOutputs := bc.FindSpendableOutputs(pubKeyHash, amt)
if total < amt {
log.Panic... | func NewTransaction(from *wallet.Wallet, to string, amount int, chain *BlockChain) *Transaction {
var inputs []TxInput
var outputs []TxOutput
pubKeyHash := wallet.PublicKeyHash(from.PublicKey)
acc, validOutputs := chain.FindSpendableOutputs(pubKeyHash, amount)
if acc < amount {
log.Panic("Error: Not enough fun... | func FundAddress(c *gin.Context) {
addr, _ := hex.DecodeString(c.Param("address")[2:])
out := blockchain.Output{
Owner: addr,
Slice: slice.Slice{Begin: 10, End: 20},
}
_, err := Manager.AssembleDepositBlock(out)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.String(... | func NewTransaction(w *wallet.Wallet, to string, amount int, utxo *UTXOSet) *Transaction {
defer HandlePanic()
var inputs []TxInput
var outputs []TxOutput
pubKeyHash := wallet.PublicKeyHash(w.PublicKey)
acc, validOutputs := utxo.FindSpendableOutputs(pubKeyHash, amount)
if acc < amount {
log.Panic("Error: not ... | func Transfer(toAddress string, amount string,ctx context.Context) (error) {
cfg, err := config.GetConfig()
if err != nil {
return err
}
client := ctx.Value(tellorCommon.ClientContextKey).(rpc.ETHClient)
privateKey, err := crypto.HexToECDSA(cfg.PrivateKey)
if err != nil {
return err
}
publicKey := private... | func NewTx(nonce uint64, to string, amount, gasPrice *ethgo.Value, gasLimit *big.Int, data []byte) *Tx {
to = strings.TrimPrefix(to, "0x")
var recipient [20]byte
toBytes, _ := hex.DecodeString(to)
copy(recipient[:], toBytes)
tx := &Tx{
AccountNonce: nonce,
Recipient: &recipient,
Payload: data,
... | func (eostx *EosTX) CreateAccountTx(userAccount, userPubkey string, balance int64, frozenTime int64, needVote bool, blockMap map[int]int64) (string, error) {
if strings.HasPrefix(userPubkey, "YTA") {
userPubkey = fmt.Sprintf("%s%s", "EOS", strings.TrimLeft(userPubkey, "YTA"))
}
eostx.API.SetCustomGetRequiredKeys(f... | func NewTx(ctx context.Context, client *ethclient.Client, fromAddress string, toAddress string, value *big.Int) (*types.Transaction, error) {
nonce, err := client.PendingNonceAt(ctx, common.HexToAddress(fromAddress))
if err != nil {
return nil, err
}
gasPrice, err := GasPrice(ctx, client)
if err != nil {
retur... | func NewCoinbaseTX(to, msg string) *Transaction {
if msg == "" {
msg = fmt.Sprintf("Reward to '%s'", to)
}
//TODO: why not set to nil
txin := TXInput{[]byte{}, -1, nil, []byte(msg)}
txout := NewTXOutput(subsidy, to)
tx := Transaction{nil, []TXInput{txin}, []TXOutput{*txout}}
tx.SetHash()
return &tx
} | func NewTokenCashierOnEthereum(
id string,
relayerURL string,
ethereumClient *ethclient.Client,
cashierContractAddr common.Address,
validatorContractAddr common.Address,
recorder *Recorder,
startBlockHeight uint64,
confirmBlockNumber uint8,
) (TokenCashier, error) {
tokenCashierABI, err := abi.JSON(strings.New... | func (w *Wallet) CreateTransaction(bc *Blockchain) *Transaction {
input := Input{
address: w.PublicKey(),
value: w.findValue(bc),
}
t := &Transaction{
outputs: []Output{},
input: input,
}
return t
} | func createTransaction(fromPubK string, fromPrK string, toPK string, nativeAmount string) string {
fmt.Println("Test Network ID: ", b.TestNetwork.ID())
fmt.Println("Test Network passphrase: ", b.TestNetwork.Passphrase)
tx, err := b.Transaction(
b.SourceAccount{AddressOrSeed: fromPubK},
b.TestNetwork,
b.AutoSe... | func NewUTXOTransaction(from,to string,amount int,blockchain *Blockchain) *Transaction {
var inputs []TXInput
var outputs []TXOutput
wallets,err := NewWallets()
if err != nil {
log.Panic(err)
}
wallet := wallets.GetWallet(from)
pubKeyHash := HashPubKey(wallet.PublicKey)
acc ,validOutputs := blockchain.FindSpe... | func (chain *Blockchain) NewTransaction(from, to string, amount int) (*Transaction, error) {
var txins []TxInput
var txous []TxOutput
store := &UtxoStore{chain}
pubKeyHash, _ := PubKeyHash(from)
spendable, outs := store.FindSpendableOutputs(pubKeyHash, amount)
if spendable < amount {
return nil, fmt.Errorf("not... | func (base *Contract) CreateToken(addr smc.Address,
name string,
symbol string,
totalsupply big.Int,
addSupplyEnabled bool,
burnEnabled bool,
gasprice uint64) smc.Error {
return base.Ctx.NewToken(addr, name, symbol, totalsupply, addSupplyEnabled, burnEnabled, gasprice)
} | func CreateAccount(address string, quarkAmount uint) (hash string, err error) {
if quarkAmount > maxQuarks {
return "", ErrInvalidCreateAmount
}
url := fmt.Sprintf("%s?addr=%s&amount=%d.%d", friendbotURL, address, quarkAmount/quarksPerKin, quarkAmount%quarksPerKin)
resp, err := http.Get(url)
if err != nil {
r... | func CreateTransaction(txToSpend *externalapi.DomainTransaction, fee uint64) (*externalapi.DomainTransaction, error) {
scriptPublicKey, redeemScript := OpTrueScript()
signatureScript, err := txscript.PayToScriptHashSignatureScript(redeemScript, nil)
if err != nil {
return nil, err
}
input := &externalapi.Domain... | func NewCoinbaseTx(pk rsa.PublicKey, txFee float64) *Transaction {
coinbase := Transaction{
Inputs: []Input{},
Outputs: []Output{
Output{COINBASE + txFee, pk},
},
IsCoinbase: true,
Ts: time.Now().UnixNano(),
}
coinbase.Hash = coinbase.hashStr()
return &coinbase
} | func (node *Node) CreateTransactionForEnterMethod(amount int64, priKey string) error {
var err error
toAddress := node.DemoContractAddress
abi, err := abi.JSON(strings.NewReader(contracts.LotteryABI))
if err != nil {
utils.GetLogInstance().Error("Failed to generate staking contract's ABI", "error", err)
return... | func CreateRawTransaction(coinSymbol string, ip string, rpcPort int, rpcUser string, rpcPass string, utxos []UTXODetail,
from string, to string, amountStr string, feeStr string, gasPrice string, gasLimit string) (string, string, error) {
coinObj,exist := config.GlobalSupportCoinMgr[coinSymbol]
if !exist{
return ""... | func NewCoinbaseTX(to string) *Transaction {
tx := Transaction{nil, time.Now().Unix(), "", to, subsidy, []byte{}, []byte{}}
tx.ID = tx.Hash()
return &tx
} | func NewAccount(addr string, tx *models.Transaction, _type int, txCount uint64) {
a := &models.Account{
Address: addr,
Vname: addr, //todo: get vname
Balance: "0",
TxCount: txCount,
FirstBlock: tx.BlockNumber,
LastBlock: tx.BlockNumber,
TokenAmount: "0",
TokenA... | func (f *Faucet) SendFunds(msg *message.Message) (m *message.Message, txID string, err error) {
// ensure that only one request is being processed any given time
f.Lock()
defer f.Unlock()
addr := msg.Payload().(*faucetpayload.Payload).Address()
if f.IsAddressBlacklisted(addr) {
return nil, "", ErrAddressIsBlac... | func NewUTXOTransaction(from, to string, amount int, bc *Blockchain) (*Transaction, error) {
var inputs []TXInput
var outputs []TXOutput
acc, validOutputs, err := bc.FindSpendableOutputs(from, amount)
if err != nil {
return nil, err
}
if acc < amount {
return nil, fmt.Errorf("Not enough funds")
}
// List... | func (k *KeyPair) CreateTx(receiver []byte, value *big.Int, data []string) *Transaction {
tx := NewTransaction(receiver, value, data)
tx.Nonce = k.account.Nonce
// Sign the transaction with the private key in this key chain
tx.Sign(k.PrivateKey)
return tx
} | func (c *blockGenerator) constructCoinbaseTx(rewardReceiver *key.PublicKey, proof []byte, score []byte) (*transactions.Coinbase, error) {
// The rewards for both the Generator and the Provisioners are disclosed.
// Provisioner reward addresses do not require obfuscation
// The Generator address rewards do.
// Cons... | func newBaseChain(
ctx context.Context,
config ethereum.Config,
client *ethclient.Client,
) (*baseChain, error) {
chainID, err := client.ChainID(ctx)
if err != nil {
return nil, fmt.Errorf(
"failed to resolve Ethereum chain id: [%v]",
err,
)
}
if config.Network != ethereum.Developer &&
big.NewInt(co... | func (_MultiSigWalletFactoryContract *MultiSigWalletFactoryContractSession) Create(_owners []common.Address, _required *big.Int) (*types.Transaction, error) {
return _MultiSigWalletFactoryContract.Contract.Create(&_MultiSigWalletFactoryContract.TransactOpts, _owners, _required)
} | func CoinbaseTx(to, data string) *Transaction {
if data == "" {
//make a new data
data = fmt.Sprintf("Coins to %s", to)
}
//define the Transaction input and output for this Coinbase
txin := TxInput{
ID: []byte{}, //is nill because is referencing no output
Out: -1, //-1 because is referencing no outp... | func (blockchain *Blockchain) CreateNewTransaction(value uint64, from string, to string, privKey ecdsa.PrivateKey, pubKey []byte) *Transaction {
previous_tx := blockchain.FindUsableUTXO(value, from)
signature := previous_tx.Sign(privKey)
isVerify := previous_tx.Verify(signature, pubKey)
if isVerify == false {
re... | func (api *JSONHTTPAPI) NewTransaction(ctx *fasthttp.RequestCtx) {
ctx.Response.Header.Set("Access-Control-Allow-Origin", "*") // Allow CORS
ctx.Response.Header.Set("Access-Control-Allow-Headers", "Content-Type") // Allow Content-Type header
ctx.Response.Header.Set("Content-Type", "application/json") ... | func newWallet(c *cli.Context) (err error) {
s := []byte(c.Args().First())
//Generate secp256k1 private key
h1 := sha3.Sum256(s)
h2 := sha3.Sum256(h1[:])
private := h2[:]
fmt.Printf("Secp256k1 private key in hexadecimal is : %X\n", h2)
//WIF private key
k := append([]byte{0x80}, private...)
hk := sha2(k)
key... | func CreateOneTxOfBTCTransfer(payacc *account.Account, toaddr fields.Address, amount uint64,
feeacc *account.Account, fee *fields.Amount, timestamp int64) (*Transaction_2_Simple, error) {
// Sign private key signature
allPrivateKeyBytes := make(map[string][]byte)
allPrivateKeyBytes[string(feeacc.Address)] = feeacc... | func newTransaction(btc *Backend, txHash, blockHash, lastLookup *chainhash.Hash,
blockHeight int64, isCoinbase bool, ins []txIn, outs []txOut, feeRate uint64) *Tx {
// Set a nil blockHash to the zero hash.
hash := blockHash
if hash == nil {
hash = &zeroHash
}
return &Tx{
btc: btc,
blockHash: *hash,
... | func CreatePayment(blockchain string, sourceAddress string, destinationAddress string, asset string, issuer string, quantity uint64, passphrase string) (Payment, *EnuError) {
// var paymentId string
var paymentStruct Payment
// Make URL from base URL
var url = baseURL() + "/wallet/payment"
type genericMap map[str... | func CreateAccountTransaction(newccountAddress string, xlmAmount string, fundingAccount *horizon.Account, network string) (createAccountTransaction *txnbuild.Transaction, err error) {
accountCreationOperation := txnbuild.CreateAccount{
Destination: newccountAddress,
Amount: xlmAmount,
SourceAccount: fu... | func NewTransaction(
nonce uint64, to ethcmn.Address, amount *big.Int, gasLimit uint64, gasPrice *big.Int, payload []byte,
) *Transaction {
return newTransaction(nonce, &to, amount, gasLimit, gasPrice, payload)
} | func (_MultiSigWalletFactoryContract *MultiSigWalletFactoryContractTransactor) Create(opts *bind.TransactOpts, _owners []common.Address, _required *big.Int) (*types.Transaction, error) {
return _MultiSigWalletFactoryContract.contract.Transact(opts, "create", _owners, _required)
} | func newRPCTransaction(tx *etypes.Transaction, blockHash common.Hash, blockNumber uint64, index uint64) *Transaction {
var signer etypes.Signer
if tx.Protected() {
signer = etypes.LatestSignerForChainID(tx.ChainId())
} else {
signer = etypes.HomesteadSigner{}
}
from, _ := etypes.Sender(signer, tx)
v, r, s := ... | func DigitalwalletToUTXOTrans(digitalWalletTx transaction.DigitalwalletTransaction) transaction.Transaction {
var transactionobj transaction.Transaction
var inoTokenID, _ = globalPkg.ConvertIntToFixedLengthString(0, globalPkg.GlobalObj.TokenIDStringFixedLength)
var feesAccIndex, _ = globalPkg.ConvertIntToFixedLengt... | func CoinbaseTx(to, data string) *Transaction {
// creates random generated data
if data == "" {
randData := make([]byte, 24)
_, err := rand.Read(randData)
if err != nil {
log.Panic(err)
}
data = fmt.Sprintf("%x", randData)
}
txin := TxInput{[]byte{}, -1, nil, []byte(data)} // references no output so e... | func (dc *DagChain) CreateTx(privKey ecdsa.PrivateKey, income [32]byte, sender, receiver string, senderNo, receiverNo int, value int) *Transaction {
var validateRef [2][32]byte
verification := false
//index, vTips := dc.SelectTips()
_, vTips := dc.SelectTips(senderNo)
for dc.VerifyTips(vTips) == false {
_, vTip... | func (_MultiSigWalletFactoryContract *MultiSigWalletFactoryContractTransactorSession) Create(_owners []common.Address, _required *big.Int) (*types.Transaction, error) {
return _MultiSigWalletFactoryContract.Contract.Create(&_MultiSigWalletFactoryContract.TransactOpts, _owners, _required)
} | func (client *Client) CreateMultiSigAccount(creator, newAccountName, fee string, accountOwners []string, keyOwners []string,
threshold uint32) (*OperResp, error) {
err := ValidateNameAccount(newAccountName)
if err != nil {
return nil, err
}
validate := ValidateFee(fee, config.MIN_ACCOUNT_CREATION_FEE)
if valida... | func (g *Generator) CreateCoinbaseTx(blockHeight uint32, numVotes uint16) *wire.MsgTx {
// Calculate the subsidy proportions based on the block height and the
// number of votes the block will include.
fullSubsidy := g.calcFullSubsidy(blockHeight)
devSubsidy := g.calcDevSubsidy(fullSubsidy, blockHeight, numVotes)
... | func Send(ctx context.Context, client Client, privateKeyHex string, address common.Address, amount *big.Int, gasPrice *big.Int, gasLimit uint64) (*Transaction, error) {
if len(privateKeyHex) > 2 && privateKeyHex[:2] == "0x" {
privateKeyHex = privateKeyHex[2:]
}
privateKey, err := crypto.HexToECDSA(privateKeyHex)
... | func CreateRawTransaction(sendTo string, amount uint64, Fee ltcutil.Amount, client *rpcclient.Client, PrivateKey string, userId uint64) *chainhash.Hash {
var addressMap = make(map[string]uint64)
currentTime := int64(0)
inputs,addressMap, ColdKey, PrivateKeyCMP := CreateInputs(client, userId, amount, PrivateKey)
if... | func NewCoin(whole int64, fractional int64,
ticker string) Coin {
return Coin{
Whole: whole,
Fractional: fractional,
Ticker: ticker,
}
} | func CalculateTokenToBuy(swapTokenPair types.SwapTokenPair, sellToken sdk.SysCoin, buyTokenDenom string, params types.Params) sdk.SysCoin {
var inputReserve, outputReserve sdk.Dec
if buyTokenDenom < sellToken.Denom {
inputReserve = swapTokenPair.QuotePooledCoin.Amount
outputReserve = swapTokenPair.BasePooledCoin.... | func (_AsnEth *AsnEthTransactor) Fund(opts *bind.TransactOpts, _id uint64, _hashSecretX [32]byte, _receiver common.Address, _token common.Address, _amount *big.Int, _expirationSender *big.Int, _expirationReceiver *big.Int) (*types.Transaction, error) {
return _AsnEth.contract.Transact(opts, "fund", _id, _hashSecretX, ... | func main() {
// アカウント作成
key, _ := crypto.GenerateKey()
auth := bind.NewKeyedTransactor(key)
// Ethereumシミュレーターを起動
conn := backends.NewSimulatedBackend(core.GenesisAlloc{
auth.From: {
PrivateKey: key.D.Bytes(),
Balance: big.NewInt(10000000000),
},
})
// トークンのデプロイ
_, _, token, err := token.DeployM... | func (_AsnEth *AsnEthSession) Fund(_id uint64, _hashSecretX [32]byte, _receiver common.Address, _token common.Address, _amount *big.Int, _expirationSender *big.Int, _expirationReceiver *big.Int) (*types.Transaction, error) {
return _AsnEth.Contract.Fund(&_AsnEth.TransactOpts, _id, _hashSecretX, _receiver, _token, _amo... | func NewFund(i float64) *Fund {
return &Fund{
balance: i,
}
} | func CreateTxWithChange(utxos []*Utxo, payToAddresses []*PayToAddress, opReturns []OpReturnData,
changeAddress string, standardRate, dataRate *bt.Fee,
privateKey *bsvec.PrivateKey) (*bt.Tx, error) {
// Missing utxo(s) or change address
if len(utxos) == 0 {
return nil, errors.New("utxo(s) are required to cr... | func accountCreate(stub shim.ChaincodeStubInterface, params []string) peer.Response {
if len(params) < 1 {
return shim.Error("incorrect number of parameters. expecting 1+")
}
code, err := ValidateTokenCode(params[0])
if err != nil {
return shim.Error(err.Error())
}
// validate available token
tb := NewToke... | func (w *HotWallet) FundTransaction(txn *sunyata.Transaction, amount sunyata.Currency, pool []sunyata.Transaction) ([]sunyata.OutputID, func(), error) {
w.mu.Lock()
defer w.mu.Unlock()
if amount.IsZero() {
return nil, func() {}, nil
}
// avoid reusing any inputs currently in the transaction pool
inPool := make... | func (t *TestServer) Fund(addr web3.Address, value *big.Int) error {
txn := web3.Transaction{
From: t.Owner(),
To: &addr,
Value: value,
}
if _, err := t.sendTxn(txn); err != nil {
return err
}
return nil
} | func balanceOf(args []string) (string, error) {
args[0] = xrc20ContractAddress
signer = "io1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqd39ym7"
gasLimit = 50000
var err error
xrc20Bytes, err = xrc20ABI.Pack("balanceOf", toEthAddr(xrc20OwnerAddress))
if err != nil {
return "", err
}
return read(args)
} | func SendTransaction(eth string, value *big.Int, toAddrHex string, data []byte, sk string) error { // private key to sign tx
// connect to chain
client, err := ethclient.Dial(eth)
if err != nil {
log.Fatal(err)
return err
}
// prepair privatekey
// string to ECDSA
privateKeyECDSA, err := crypto.HexToECDSA(... | func NewAmount(f float64) (Amount, error) {
// The amount is only considered invalid if it cannot be represented
// as an integer type. This may happen if f is NaN or +-Infinity.
switch {
case math.IsNaN(f):
fallthrough
case math.IsInf(f, 1):
fallthrough
case math.IsInf(f, -1):
return 0, errors.New("invali... | func NewTransaction(input Input, output Output, key *rsa.PrivateKey) *Transaction {
hashed := GetHashToSign(input, []Output{output})
sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, hashed[:])
if err != nil {
return nil
}
input.Signature = sig
tx := Transaction{
Inputs: []Input{input},
Outp... | func (_AsnEth *AsnEthTransactorSession) Fund(_id uint64, _hashSecretX [32]byte, _receiver common.Address, _token common.Address, _amount *big.Int, _expirationSender *big.Int, _expirationReceiver *big.Int) (*types.Transaction, error) {
return _AsnEth.Contract.Fund(&_AsnEth.TransactOpts, _id, _hashSecretX, _receiver, _t... | func blockchainStartNewPayment(price int64, externalPayerId int64, externalReceiverId int64) (*types.Transaction, error){
//0xfb7974b7616a0c0dbd08c7fee7f1291548045e33 is the contract's address gicen by the deploySmartContract function in blockchain_main.go
contract, err := contracts.NewPayments(common.HexToAddr... | func NewBitcoin() *bitcoin {
return &bitcoin{amount: 0}
} | func createTxOut(inCoin int64, addr btcutil.Address) *btcwire.TxOut {
// Pay the minimum network fee so that nodes will broadcast the tx.
outCoin := inCoin - 10000
// Take the address and generate a PubKeyScript out of it
script, err := btcscript.PayToAddrScript(addr)
if err != nil {
log.Fatal(err)
}
txout := ... | func TestMakePaymentTxn2(t *testing.T) {
const fromAddress = "47YPQTIGQEO7T4Y4RWDYWEKV6RTR2UNBQXBABEEGM72ESWDQNCQ52OPASU"
const toAddress = "PNWOET7LLOWMBMLE4KOCELCX6X3D3Q4H2Q4QJASYIEOF7YIPPQBG3YQ5YI"
params := types.SuggestedParams{
Fee: 4,
FirstRoundValid: 12466,
LastRoundValid: 13466,
Genesis... | func (n *txManager) CreateCurrencyTransaction(PubKey []byte, privKey ecdsa.PrivateKey, to string, amount float64) (*structures.Transaction, error) {
if amount <= 0 {
return nil, errors.New("Amount must be positive value")
}
if to == "" {
return nil, errors.New("Recipient address is not provided")
}
txBytes, ... | func makeCallTx(t *testing.T, typ string, from, to, data []byte, amt, gaslim, fee uint64) *types.CallTx {
acc := getAccount(t, typ, from)
nonce := 0
if acc != nil {
nonce = int(acc.Sequence) + 1
}
bytePub, err := hex.DecodeString(userPub)
if err != nil {
t.Fatal(err)
}
tx := &types.CallTx{
Input: &types.... | func Test_GenerateWalletWithDummyFunds(t *testing.T) {
notSolo := notsolo.New(t)
// Generates a key pair for a wallet and provides it with dummy funds.
// The amount is defined in Wasp (constant testutil.RequestFundsAmount) and WaspConn plug-in (constant utxodb.RequestFundsAmount)
walletSigScheme := notSolo.SigSch... | func NewAmount(f float64) (uint64, error) {
// The amount is only considered invalid if it cannot be represented
// as an integer type. This may happen if f is NaN or +-Infinity.
switch {
case math.IsNaN(f):
fallthrough
case math.IsInf(f, 1):
fallthrough
case math.IsInf(f, -1):
return 0, errors.New("invali... | func NewCoin(asset Asset, amount cosmos.Uint) Coin {
return Coin{
Asset: asset,
Amount: amount,
}
} | func (w *Wallet) CreateTransaction(p transaction.Params, auxs coin.AddressUxOuts, headTime uint64) (*coin.Transaction, []transaction.UxBalance, error) {
if err := p.Validate(); err != nil {
return nil, nil, err
}
// Check that auxs does not contain addresses that are not known to this wallet
for a := range auxs ... | func createAccount(t *testing.T, b *emulator.Blockchain) (sdk.Address, crypto.Signer, *sdk.AccountKey) {
accountKeys := test.AccountKeyGenerator()
accountKey, signer := accountKeys.NewWithSigner()
address, err := b.CreateAccount([]*sdk.AccountKey{accountKey}, nil)
require.NoError(t, err)
return address, signer, ac... | func (c TokenContract) Create(issuer string, maxSupply string) {
c.PushAction(
"create",
map[string]interface{}{
"issuer": issuer,
"maximum_supply": maxSupply,
},
&Permission{
Actor: c.Account.Name,
Level: "active",
},
)
} | func New(from string, to string, currency account.Currency, amount float64) *Transaction {
return &Transaction{
From: from,
To: to,
Currency: currency,
Amount: amount,
}
} | func (evm *EVM) create(caller ContractRef, codeAndHash *codeAndHash, gas uint64, value *big.Int, contractAddr common.Address) ([]byte, common.Address, uint64, error) {
// Depth check execution. Fail if we're trying to execute above the
// limit.
if evm.depth > int(cfg.CallCreateDepth) {
return nil, common.EmptyAdd... | func pay(ctx context.Context, hostIP, addressInput, amountInput, overridetokenInput string) (string, error) {
// Ensure only one pay function request can run at a time.
requestMtx.Lock()
defer requestMtx.Unlock()
amountMtx.RLock()
tLimit := transactionLimit
amountMtx.RUnlock()
var amount dcrutil.Amount
if cfg... | func decodeTokenFundingCoin(coinID []byte) (*tokenFundingCoin, error) {
if len(coinID) != tokenFundingCoinIDSize {
return nil, fmt.Errorf("decodeTokenFundingCoin: length expected %v, got %v",
tokenFundingCoinIDSize, len(coinID))
}
var address [20]byte
copy(address[:], coinID[:20])
return &tokenFundingCoin{
... | func newWallet(cfg *BTCCloneCFG, btcCfg *dexbtc.Config, node rpcClient) *ExchangeWallet {
// If set in the user config, the fallback fee will be in conventional units
// per kB, e.g. BTC/kB. Translate that to sats/B.
fallbackFeesPerByte := toSatoshi(btcCfg.FallbackFeeRate / 1000)
if fallbackFeesPerByte == 0 {
fal... | func makeSendTx(t *testing.T, typ string, from, to []byte, amt uint64) *types.SendTx {
acc := getAccount(t, typ, from)
nonce := 0
if acc != nil {
nonce = int(acc.Sequence) + 1
}
bytePub, err := hex.DecodeString(userPub)
if err != nil {
t.Fatal(err)
}
tx := &types.SendTx{
Inputs: []*types.TxInput{
&type... | func TestTransferAndRegisterAccount(t *testing.T) {
newResetPriv := secp256k1.GenPrivKey()
newTransactionPriv := secp256k1.GenPrivKey()
newAppPriv := secp256k1.GenPrivKey()
newAccountName := "newuser"
lb := test.NewTestLinoBlockchain(t, test.DefaultNumOfVal)
baseTime := time.Now().Unix()
registerMsg := acc.New... | func NewTransaction(utxos interface{}, outAddrs []TxOut) (*Transaction, error) {
s := reflect.ValueOf(utxos)
if s.Kind() != reflect.Slice {
return nil, errors.New("error utxo type")
}
ret := make([]interface{}, s.Len())
for i := 0; i < s.Len(); i++ {
ret[i] = s.Index(i).Interface()
}
tx := wire.NewMsgTx()
... | func NewFund(initialBalance int64) *Fund {
return &Fund{
balance: initialBalance,
}
} | func (node *Node) CreateTransactionForPickWinner() error {
var err error
toAddress := node.DemoContractAddress
abi, err := abi.JSON(strings.NewReader(contracts.LotteryABI))
if err != nil {
utils.GetLogInstance().Error("Failed to generate staking contract's ABI", "error", err)
return err
}
bytesData, err := a... | func (g *Generator) CreateSpendTx(spend *SpendableOut, fee ndrutil.Amount) *wire.MsgTx {
spendTx := wire.NewMsgTx()
spendTx.AddTxIn(&wire.TxIn{
PreviousOutPoint: spend.prevOut,
Sequence: wire.MaxTxInSequenceNum,
ValueIn: int64(spend.amount),
BlockHeight: spend.blockHeight,
BlockIndex: ... | func (stats *FeeEstimator) newMemPoolTx(bucketIdx int32, fees feeRate) {
conf := &stats.memPool[bucketIdx].confirmed[0]
conf.feeSum += float64(fees)
conf.txCount++
} | func newTransaction(client *rpcclient.Client, matches []TxMatch, dest soterutil.Address, amount, fee soterutil.Amount) (*wire.MsgTx, error) {
txIns := makeTxInputs(matches, amount, fee)
txAmts := makeTxAmts(matches, dest, amount, fee)
// Have the soterd node translate our inputs and amounts into a raw transaction
r... | [
"0.69182605",
"0.604568",
"0.6040604",
"0.5981004",
"0.5937574",
"0.5924449",
"0.59152853",
"0.5899967",
"0.5891179",
"0.584104",
"0.5833688",
"0.5744425",
"0.5728572",
"0.5722755",
"0.5699103",
"0.56662744",
"0.5665291",
"0.566393",
"0.5651559",
"0.5651254",
"0.5647998",
"... |
Copy returns a new Text struct with the same values as the Text it was called from. Except the Content field, that's empty. | func (txt Text) Copy() Text {
var newText Text
if txt.Bold {
newText.Bold = true
}
if txt.Italic {
newText.Italic = true
}
if txt.Code {
newText.Code = true
}
if txt.Strike {
newText.Strike = true
}
newText.HREF = txt.HREF[:]
return newText
} | func (t *Text) Copy() device.Resulter {
if t == nil {
return nil
}
return &Text{Text: t.Text}
} | func (t *Text) DeepCopy() Element {
rgaTreeSplit := NewRGATreeSplit(InitialTextNode())
current := rgaTreeSplit.InitialHead()
for _, node := range t.Nodes() {
current = rgaTreeSplit.InsertAfter(current, node.DeepCopy())
insPrevID := node.InsPrevID()
if insPrevID != nil {
insPrevNode := rgaTreeSplit.FindNode... | func (t Text) Clone() Text {
newt := make(Text, len(t))
for i, seg := range t {
newt[i] = seg.Clone()
}
return newt
} | func (recv *TextAttributes) Copy() *TextAttributes {
retC := C.gtk_text_attributes_copy((*C.GtkTextAttributes)(recv.native))
retGo := TextAttributesNewFromC(unsafe.Pointer(retC))
return retGo
} | func (t *TextValue) DeepCopy() RGATreeSplitValue {
return &TextValue{
value: t.value,
}
} | func (recv *TextIter) Copy() *TextIter {
retC := C.gtk_text_iter_copy((*C.GtkTextIter)(recv.native))
retGo := TextIterNewFromC(unsafe.Pointer(retC))
return retGo
} | func (dtl *DefaultTextLine) Copy() device.Resulter {
if dtl == nil {
return nil
}
return &DefaultTextLine{
Line: dtl.Line,
Text: dtl.Text}
} | func (recv *EditableText) CopyText(startPos int32, endPos int32) {
c_start_pos := (C.gint)(startPos)
c_end_pos := (C.gint)(endPos)
C.atk_editable_text_copy_text((*C.AtkEditableText)(recv.native), c_start_pos, c_end_pos)
return
} | func (t PlainText) Content() []byte {
return t
} | func NewText() *Text {
t := &Text{
entity: NewEntity(TEXT),
Coord1: []float64{0.0, 0.0, 0.0},
Coord2: []float64{0.0, 0.0, 0.0},
Height: 1.0,
Value: "",
Style: table.ST_STANDARD,
GenFlag: 0,
HorizontalFlag: 0,
VerticalFlag: 0,
}
return t
} | func NewText(font *Font) *Text {
txt := Text{}
txt.backgroundColor = Transparent
txt.font = font
txt.isClean = true
return &txt
} | func (P *Plaintext) CopyNew() BfvElement {
PCopy := new(Plaintext)
PCopy.value = make([]*ring.Poly, P.Degree()+1)
for i := range P.value {
PCopy.value[i] = P.value[i].CopyNew()
}
PCopy.bfvcontext = P.bfvcontext
PCopy.isNTT = P.isNTT
return PCopy
} | func (t *TextData) Text(txt string) *TextData {
t.text = append(t.text, txt)
t.color = append(t.color, config.FG)
return t
} | func (t TextEmpty) construct() RichTextClass { return &t } | func (r Record) Copy(content string) Record {
r.Content = content
return r
} | func (o *Char) Copy() Object {
return &Char{Value: o.Value}
} | func (tf *TextField) Copy(reset bool) string {
wupdt := tf.Viewport.Win.UpdateStart()
defer tf.Viewport.Win.UpdateEnd(wupdt)
tf.SelectUpdate()
if !tf.HasSelection() {
return ""
}
cpy := tf.Selection()
oswin.TheApp.ClipBoard(tf.Viewport.Win.OSWin).Write(mimedata.NewText(cpy))
if reset {
tf.SelectReset()
}
... | func (r *TextFileReader) Clone() interface{} {
s := *r
return &s
} | func NewText() *Text {
tview.Styles.PrimitiveBackgroundColor = tcell.ColorDefault
tv := Text{screen: NewScreen()}
tv.init()
return &tv
} | func (P *Plaintext) Copy(PCopy BfvElement) error {
if !checkContext([]BfvElement{P, PCopy}) {
return errors.New("input ciphertext are not using the same bfvcontext")
}
for i := range P.value {
PCopy.Value()[i].Copy(P.Value()[i])
}
P.SetIsNTT(P.IsNTT())
return nil
} | func (recv *NoOpObject) Text() *Text {
return TextNewFromC(recv.ToC())
} | func (t TextPlain) construct() RichTextClass { return &t } | func NewText(text string, row, col uint) Text {
t := Text{Text: text}
t.SetPosition(row, col)
return t
} | func (t *tree) Copy() *tree {
if t == nil {
return nil
}
return &tree{
Name: t.Name,
Root: t.Root.CopyList(),
text: t.text,
}
} | func (ct *Ciphertext) Copy() *Ciphertext {
return &Ciphertext{ct.Coefficients, ct.Degree, ct.ScaleFactor, ct.L2}
} | func Text(text string) *Node {
return TextType(TextNode, TextNode.String(), TextContent(text))
} | func (ftu *FieldTypeUpdate) ClearText() *FieldTypeUpdate {
ftu.mutation.ClearText()
return ftu
} | func (editor *Editor) Text(text string) {
editor.buffer.Remove(editor.buffer.Start(), editor.buffer.End())
editor.buffer.Insert(editor.buffer.Start(), text)
} | func (t Transaction) Copy() payload.Safe {
return t.deepCopy()
} | func (textToSpeech *TextToSpeechV1) Clone() *TextToSpeechV1 {
if core.IsNil(textToSpeech) {
return nil
}
clone := *textToSpeech
clone.Service = textToSpeech.Service.Clone()
return &clone
} | func (e *textView) Text(buf []byte) []byte {
size := e.rr.Size()
if cap(buf) < int(size) {
buf = make([]byte, size)
}
buf = buf[:size]
e.Seek(0, io.SeekStart)
n, _ := io.ReadFull(e, buf)
buf = buf[:n]
return buf
} | func (recv *TextAttributes) CopyValues(dest *TextAttributes) {
c_dest := (*C.GtkTextAttributes)(C.NULL)
if dest != nil {
c_dest = (*C.GtkTextAttributes)(dest.ToC())
}
C.gtk_text_attributes_copy_values((*C.GtkTextAttributes)(recv.native), c_dest)
return
} | func (t TextContent) String() string {
return string(t)
} | func (ftuo *FieldTypeUpdateOne) ClearText() *FieldTypeUpdateOne {
ftuo.mutation.ClearText()
return ftuo
} | func (src *ModelTxtMeta) Clone() (*ModelTxtMeta, error) {
var dst ModelTxtMeta
if err := helper.DeepCopy(src, &dst); err != nil {
return nil, err
}
return &dst, nil
} | func (gui *GUI) NewText(t Text) {
gui.texts = append(gui.texts, t)
} | func (recv *FontDescription) Copy() *FontDescription {
retC := C.pango_font_description_copy((*C.PangoFontDescription)(recv.native))
var retGo (*FontDescription)
if retC == nil {
retGo = nil
} else {
retGo = FontDescriptionNewFromC(unsafe.Pointer(retC))
}
return retGo
} | func (s BinaryString) Copy() PropValue {
return s
} | func Text(s string) *Node {
// Wrapped in a node to allow formatting, since formatting methods
// don't work directly on text nodes.
return New(&Node{nodeType: ntText, content: s})
} | func (t TextConcat) construct() RichTextClass { return &t } | func TextFromSegment(seg *Segment) Text {
if seg.Text == "" {
return nil
}
return Text{seg}
} | func (c contentBase) GetText() []byte {
return nil
} | func (t *DatatypeText) CopyTo(copyTo ...string) *DatatypeText {
t.copyTo = append(t.copyTo, copyTo...)
return t
} | func (t *TestDescription) Copy() *TestDescription {
newT := TestDescription{t.Description, t.Path, t.KeyWords, t.Includes,
t.Run, t.Checks, nil}
return &newT
} | func (node Node) TextUnsafe(text string) Node {
node.text = text
return node
} | func (msg MessageImmutable) Text() (text string) {
if msg.text < 1 {
text = ""
return
}
text = string(msg.buffer[msg.text:])
return
} | func NewText(elements *RGATreeSplit, createdAt *time.Ticket) *Text {
return &Text{
rgaTreeSplit: elements,
selectionMap: make(map[string]*Selection),
createdAt: createdAt,
}
} | func NewText(p *Point, data string) *Text {
return &Text{data, NewDrawable(p)}
} | func (p Ptr) Text() string {
b, ok := p.text()
if !ok {
return ""
}
return string(b)
} | func (v *String) Clone() Value { return NewString(*v.valPtr) } | func (c *Command) Copy() *Command {
nc := *c
// reset some fields
nc.Func = nil
nc.Hooks.ClearHooks() // TODO bug, will clear c.Hooks
// nc.Flags = flag.FlagSet{}
return &nc
} | func copyText(text string, object hash.Hash) {
f, err := os.Open(text)
if err != nil {
fmt.Println("Error al abrir el archivo")
} else {
io.Copy(object, f) // Copy the text contents to object
}
f.Close()
} | func (c *Command) Copy() *Command {
nc := *c
// reset some fields
nc.Func = nil
nc.Hooks.ClearHooks()
// nc.Flags = flag.FlagSet{}
return &nc
} | func (c *Command) Copy() *Command {
nc := *c
// reset some fields
nc.Func = nil
nc.Hooks.ClearHooks()
// nc.Flags = flag.FlagSet{}
return &nc
} | func (e *RawNode) Text(text string) Node {
return e.Children(Text(text))
} | func (ct *Ciphertext) CopyNew() *Ciphertext {
return &Ciphertext{ct.Element.CopyNew()}
} | func (this Quat) Copy() Quat {
return this
} | func (ct Ciphertext) Clone() *Ciphertext {
c := NewCiphertext()
c.C.Set(ct.C)
return c
} | func (me *Node) Copy() *Node {
cp := *me
cp.Child = nil
cp.Sibling = nil
cp.Content = nil
return &cp
} | func (m Message) Copy() *Message {
return &Message{
Prefix: m.Prefix,
Command: m.Command,
Args: append(make([]string, 0, len(m.Args)), m.Args...),
}
} | func (m *Message) Copy() *Message {
// Create a new message
newMessage := &Message{}
// Copy stuff from the old message
*newMessage = *m
// Copy the Prefix
newMessage.Prefix = m.Prefix.Copy()
// Copy the Params slice
newMessage.Params = append(make([]string, 0, len(m.Params)), m.Params...)
return newMessag... | func NewText(data []byte, path string, GNtaggerVersion string) *Text {
path = preparePath(path)
checksum := fmt.Sprintf("%x", sha1.Sum(data))
meta := TextMeta{
Checksum: checksum,
Timestamp: timestamp(),
GNtaggerVersion: GNtaggerVersion,
}
text := &Text{
Raw: data,
Path: path,
Te... | func NewText(txt string) *Element {
em := NewElement("text", false)
em.allowChildren = false
em.allowAttributes = false
em.allowStyles = false
em.allowEvents = false
em.textContent = txt
return em
} | func (t TextFixed) construct() RichTextClass { return &t } | func NewText(val string) *Leaf {
val = strings.TrimRight(val, "\n") + "\n"
leaf := NewLeaf("", val)
leaf.typ = TextType
return leaf
} | func Text(text string) Template {
return TextBytes([]byte(text))
} | func (m *Type) ShallowCopy() types.Message {
var metadata map[string]string
if m.metadata != nil {
metadata = make(map[string]string, len(m.metadata))
for k, v := range m.metadata {
metadata[k] = v
}
}
newPartCaches := make([]*partCache, len(m.partCaches))
for i, c := range m.partCaches {
if c == nil {
... | func (p *Post) Copy() orm.CloneableData {
return &Post{
Title: p.Title,
Author: p.Author,
Text: p.Text,
CreationBlock: p.CreationBlock,
}
} | func (v *Bytes) Clone() *Bytes {
return NewBytes(v.Val())
} | func (m *Message) TextContent(text string, title string, copytext string, autocopy string) *Message {
ctx := &pb.MsgContent{
Type: pb.MsgType_Text,
Text: text,
}
if len(title) > 0 {
ctx.Title = title
}
if len(copytext) > 0 {
ctx.Copytext = copytext
}
if len(autocopy) > 0 {
ctx.Flags = 1
}
m.Content, ... | func NewText(geometry *TextGeometry, material Texter) *Text {
material.SetTexture(geometry.Font.texture)
t := Text{
material: material,
geometry: geometry,
}
t.vertexBuffer = newTextVertexBuffer(t.geometry)
t.uvBuffer = newUvBuffer(t.geometry.UVs, true)
return &t
} | func NewText(x, y int, text string, fg, bg Attr) *Text {
str := []rune(text)
c := make([]Cell, len(str))
for i := range c {
c[i] = Cell{Ch: str[i], Fg: fg, Bg: bg}
}
return &Text{x: x, y: y, canvas: c}
} | func (ct *Ciphertext) Copy(ctp *Ciphertext) {
ct.Element.Copy(ctp.Element)
} | func (n *Node) Text() string {
if n.content == nil {
return emptyContent
}
return n.content.String()
} | func NewText(c *TextConfig) *Text {
var templateFuncs = defaultTemplateFuncs
templateFuncs["executeTemplate"] = executeTemplateFunc(c.Output, c.Override)
c.fillValues()
return &Text{
output: c.Output,
padding: c.Padding,
templater: template.New("text"),
funcs: templateFunc... | func updateText(t *Text, sertext *dumpfile.Text, display draw.Display) *Text {
t.display = display
t.fr = &MockFrame{}
t.Insert(0, []rune(sertext.Buffer), true)
t.SetQ0(sertext.Q0)
t.SetQ1(sertext.Q1)
return t
} | func (self *selectionImpl) Text(f func(js.Object) string) Selection {
return &selectionImpl{
self.obj.Call("text", f),
}
} | func (h *Header) Copy() *Header {
return &Header{h.Version, h.Type, h.Length, h.Transaction}
} | func (node Node) Text(text string) Node {
node.text = golang_html.EscapeString(text)
return node
} | func (c *Command) Copy() *Command {
return &Command{
ID: c.ID,
Background: c.Background,
Command: c.Command,
FilesSend: c.FilesSend,
FilesRecv: c.FilesRecv,
CheckedIn: c.CheckedIn,
Filter: c.Filter,
PID: c.PID,
}
} | func (t *Template) copy(c *common) *Template {
nt := New(t.name)
nt.Tree = t.Tree
nt.common = c
nt.leftDelim = t.leftDelim
nt.rightDelim = t.rightDelim
return nt
} | func (in *TxtRecord) DeepCopy() *TxtRecord {
if in == nil {
return nil
}
out := new(TxtRecord)
in.DeepCopyInto(out)
return out
} | func (c *TableCipher) Copy() Cipher {
return c
} | func NewText(val string) TextField {
return TextField{quickfix.FIXString(val)}
} | func Text(t string) *html.Node {
return &html.Node{
Type: html.TextNode,
Data: t,
}
} | func (t *Transcript) Clone() *Transcript {
return &Transcript{
s: *t.s.Clone(),
}
} | func (*contentTextR) NewStruct() *contentTextR {
return &contentTextR{}
} | func (t *Tree) Copy() *Tree {
tree := MakeTree()
tree.Name = t.Name
if t.IsLeaf() {
tree.Value = t.Value
} else {
for _, n := range t.Nodes {
tree.Append(n.Copy())
}
}
return tree
} | func NewText(text string, x, y, width, height float32, font *Font) Text {
return Text{Text: text, X: x, Y: y, Width: width, Height: height, Font: font}
} | func (t TextBold) construct() RichTextClass { return &t } | func (t *TextView) Clear() *TextView {
t.buffer = nil
t.recentBytes = nil
t.index = nil
return t
} | func (meta Metadata) Copy() Metadata {
return Join(meta)
} | func (d *DOM) NewText(text string) *js.Object {
return d.doc.Call("createTextNode", text)
} | func (t DString) DeepCopy() Expr { return t } | func (bc BufferChunk) Copy() BufferChunk {
data := make([]byte, len(bc.Data))
copy(data, bc.Data)
return BufferChunk{
Timestamp: bc.Timestamp,
Data: data,
}
} | func (l Literal) Copy() Literal {
return Literal{l.Name, l.Negated}
} | func (t *DatatypeText) Source(includeName bool) (interface{}, error) {
// {
// "test": {
// "type": "text",
// "copy_to": ["field_1", "field_2"],
// "analyzer": "my_analyzer",
// "boost": 2,
// "eager_global_ordinals": true,
// "fielddata": true,
// "fielddata_frequency_filter": {
// "min": ... | func (t TextMarked) construct() RichTextClass { return &t } | func NewText(text string, center image.Point, color, background color.Color, size float64) *Text {
c := &Text{
Text: text,
Center: center,
Color: color,
Background: background,
Size: size}
c.SetText(text)
return c
} | func NewTextValue(x string) Value {
return &value{
tp: TextValue,
v: x,
}
} | [
"0.74128425",
"0.6974251",
"0.6896577",
"0.6396208",
"0.6180237",
"0.6164815",
"0.61351514",
"0.60927576",
"0.59920144",
"0.5983566",
"0.592794",
"0.58795464",
"0.5876261",
"0.5870472",
"0.5849372",
"0.5810182",
"0.58094645",
"0.57389665",
"0.5722488",
"0.5700991",
"0.5700090... |
newFeedService returns a new BoardService. | func newBoardService(sling *sling.Sling) *BoardService {
return &BoardService{
sling: sling,
}
} | func NewBoardService(settings *config.Settings) *BoardService {
brd := &BoardService{
boards: []domain.Board{},
Settings: settings,
}
if err := brd.read(settings.BoardsPath); err != nil {
log.Println("Error reading boards:", err)
}
return brd
} | func NewBoardService(dao daos.BoardDAO) *BoardService {
return &BoardService{dao}
} | func NewService() Service { return new(service) } | func NewService(
orm ORM,
jobORM job.ORM,
db *sqlx.DB,
jobSpawner job.Spawner,
keyStore keystore.Master,
insecureCfg InsecureConfig,
jobCfg JobConfig,
ocrCfg OCRConfig,
ocr2Cfg OCR2Config,
dbCfg pg.QConfig,
legacyChains evm.LegacyChainContainer,
lggr logger.Logger,
version string,
) *service {
lggr = lggr... | func newService(client gwc.Doer) *service {
return &service{gwc.NewGroup(client)}
} | func newService(name, displayName, description string) (*windowsService, error) {
return &windowsService{
name: name,
displayName: displayName,
description: description,
}, nil
} | func newService(ctx context.Context, cfg *config.Config, log *log.Logger, cancel context.CancelFunc) svc.Service {
sn := cfg.ValOrDef("svc.name", "raddare")
sr := cfg.ValOrDef("svc.revision", "n/a")
s := svc.NewService(ctx, cfg, log, cancel, sn, sr)
return s
} | func newService(c *onet.Context) (onet.Service, error) {
s := &Service{
ServiceProcessor: onet.NewServiceProcessor(c),
}
if err := s.RegisterHandlers(s.Bid, s.Close); err != nil {
// return nil, errors.New("Couldn't register messages")
return nil, err
}
return s, nil
} | func newService() v1.Service {
ret := v1.Service{
TypeMeta: meta.TypeMeta{
Kind: "Service",
APIVersion: "v1",
},
ObjectMeta: meta.ObjectMeta{
Name: fmt.Sprintf("%v", uuid.NewUUID()),
Namespace: "default",
},
Spec: v1.ServiceSpec{
Type: v1.ServiceTypeLoadBalancer,
LoadBa... | func newCategoryService(svc *Service) contract.CategoryService {
return &categoryService{
svc: svc,
}
} | func NewService(r Repository) *Service {
return &Service{
repo: r,
}
} | func (m *CollectorServiceFactory) New(name string, c core.Config, ch chan core.ServiceCommand) (core.Service, error) {
// check mongo db configuration
hosts, err := c.String("ceilometer", "mongo")
if err != nil || hosts == "" {
return nil, errors.New("Invalid mongo configuration")
}
// try connect with mongo db
... | func (c *Controller) newService(svc *corev1.Service, foo *samplev1alpha1.ServiceRoute) *corev1.Service {
newsvc := corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: foo.Spec.RouteName,
Namespace: c.istio.istio_ns,
},
Spec: corev1.ServiceSpec{
Ports: svc.Spec.Ports,
Type: corev1.ServiceTypeC... | func (r *Service) new() *corev1.Service {
return &corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: appName,
Namespace: r.Owner.Namespace,
Labels: map[string]string{
"app": appName,
},
},
Spec: corev1.ServiceSpec{
Ports: []corev1.ServicePort{
{
Name: "nfs",
Port: int32(20... | func NewService(service string) (Service, error) {
switch service {
case Twitter.Name():
return Twitter, nil
case Github.Name():
return Github, nil
case Reddit.Name():
return Reddit, nil
case HTTPS.Name():
return HTTPS, nil
default:
return nil, errors.Errorf("invalid service %s", service)
}
} | func (r *registry) newService() *core.Service {
return new(builders.ServiceBuilder).
WithMeta(r.key.Name, r.key.Namespace).
WithOwnerLabel(r.key.Name, r.key.Namespace).
WithSpec(r.newServiceSpec()).
Service()
} | func newServiceForCR(cr *wordpressv1alpha1.Wordpress) *corev1.Service {
labels := map[string]string{
"app": cr.Name,
}
port := cr.Spec.Port
return &corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: cr.Name,
Namespace: cr.Namespace,
Labels: labels,
},
Spec: corev1.S... | func newService(localService *localserviceV1alpha1.LocalService, node string) *corev1.Service {
spec := localService.Spec.ServiceSpec.DeepCopy()
spec.Selector[RackKey] = node
return &corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: localService.Name + "-" + node,
Namespace: localService.Namespace,
... | func (this *ApiServiceFactory) New(protocol string, c core.Config, ch chan core.ServiceCommand) (core.Service, error) {
// check mongo db configuration
hosts, err := c.String("iothub", "mongo")
if err != nil || hosts == "" {
return nil, errors.New("Invalid mongo configuration")
}
// try connect with mongo db
s... | func newService(c *onet.Context) (onet.Service, error) {
s := &Service{
ServiceProcessor: onet.NewServiceProcessor(c),
}
if err := s.RegisterHandlers(s.CreateSkipchain, s.SetKeyValue,
s.GetProof); err != nil {
log.ErrFatal(err, "Couldn't register messages")
}
if err := s.tryLoad(); err != nil {
log.Error(e... | func newBusinessService(svc *Service) contract.BusinessService {
return &businessService{
svc: svc,
}
} | func newService(repo healthcheck.DASRepo) *Service {
return &Service{
DASRepo: repo,
Result: NewEmptyResult(),
}
} | func NewService(config *Config, db storage.KeyValue, pastel pastel.Client) *Service {
return &Service{
config: config,
db: db,
pastel: pastel,
worker: NewWorker(),
}
} | func NewService(database model.Database, port string) (*Service, error) {
if database == nil {
return nil, errors.New("Service given nil database")
}
if port == "" {
return nil, errors.New("Service port can't be blank")
}
service := &Service{
Router: mux.NewRouter(),
versionRouters: make(map[strin... | func NewService(r Repository, se endpoint.Endpoint, le endpoint.Endpoint) *Service {
return &Service{repository: r,
addReviewToSearch: se,
addReviewToListing: le,
}
} | func newService() *service {
s := &service{}
s.setupRoutes()
s.db = &data.DB{}
s.db.Connect()
s.db.Setup()
env := os.Getenv("SCRIEVE_ENV")
if env == "development" {
log.SetFlags(log.Lshortfile)
} else if env == "production" {
log.SetFlags(log.Ldate | log.Ltime | log.Lshortfile)
}
return s
} | func newService(opts *configpb.Options, proj string, hc *http.Client, l *logger.Logger) (*service, error) {
if opts == nil {
return nil, fmt.Errorf("lameduck.Init: failed to construct lameduck Service: no lameDuckOptions given")
}
if l == nil {
l = &logger.Logger{}
}
cfg := opts.GetRuntimeconfigName()
rtc, ... | func newService(opts *configpb.Options, proj string, hc *http.Client, l *logger.Logger) (*service, error) {
if opts == nil {
return nil, fmt.Errorf("lameduck.Init: failed to construct lameduck Service: no lameDuckOptions given")
}
if l == nil {
l = &logger.Logger{}
}
cfg := opts.GetRuntimeconfigName()
rtc, ... | func NewService(serviceCClient *ServiceCClient) *Service {
newDB := map[string]Item{
"1": {
ID: "1",
Name: "item one",
},
"2": {
ID: "2",
Name: "item two",
},
"3": {
ID: "3",
Name: "item three",
},
"4": {
ID: "4",
Name: "item four",
},
"5": {
ID: "5",
Name: "it... | func NewService(
schedule core.ScheduleStore,
event core.EventStore,
conf *dashboardconfig.ChaosDashboardConfig,
scheme *runtime.Scheme,
) *Service {
return &Service{
schedule: schedule,
event: event,
conf: conf,
scheme: scheme,
}
} | func NewService() (*Configs, error) {
return &Configs{}, nil
} | func NewService(serviceName string, cfg *config.Config) factory.ServiceFactory {
deps := configs.LoadConfigs(cfg)
modules := []factory.ModuleFactory{
acl.NewModule(deps),
apps.NewModule(deps),
}
return &Service{
deps: deps,
modules: modules,
name: types.Service(serviceName),
}
} | func NewService(cat Catalog, tweetapi TweetAPI) Service {
return &service{cat, tweetapi}
} | func newMessageService() *messageService {
return &messageService{}
} | func NewConsumerService(httpClient *http.Client, config *config.KongConfiguration) *ConsumerService {
return &ConsumerService{
sling: sling.New().Client(httpClient).Base(config.KongAdminURL + "consumers/"),
config: config,
}
} | func newDataService() *corev1.Service {
return &corev1.Service{
TypeMeta: metav1.TypeMeta{},
ObjectMeta: metav1.ObjectMeta{
Name: "scalog-headless-data-service",
Namespace: "scalog",
Labels: map[string]string{
"role": "scalog-headless-data-service",
},
},
Spec: corev1.ServiceSpec{
Ports... | func NewHackerNewsService(apiKey string) Service {
return &service{
apiKey: apiKey,
}
} | func NewService(c api.ClientReader) *Service {
return &Service{c}
} | func NewService(r beerscli.BeerRepo) Service {
return &service{r}
} | func NewService() Service {
return service{}
} | func NewService(repo repository.Interface, team teamservice.Interface) *Service {
return &Service{repo: repo, team: team}
} | func NewService(c *orgbot.Config, f *ClientFactory, sess *session.Session) (orgbot.GitHubService, error) {
s := service{
ClientFactory: *f,
config: c,
s3Client: aws.NewS3(sess),
userCache: map[string]map[string]*orgbot.GitHubUser{},
}
return &s, nil
} | func NewService(db *bolt.DB, producer *nsq.Producer) (*CommandService, error) {
err := db.Update(func(tx *bolt.Tx) error {
_, err := tx.CreateBucketIfNotExists([]byte(CommandBucket))
if err != nil {
return fmt.Errorf("create bucket: %s", err)
}
return nil
})
if err != nil {
return nil, err
}
return &C... | func constructMigratedService(originalService serving_v1alpha1_api.Service, namespace string) *serving_v1alpha1_api.Service {
service := serving_v1alpha1_api.Service{
ObjectMeta: originalService.ObjectMeta,
}
service.ObjectMeta.Namespace = namespace
service.Spec = originalService.Spec
service.Spec.Template.Obje... | func NewService(
cfg *configs.Config,
store Store,
km keys.Manager,
fc *client.Client,
wp *jobs.WorkerPool,
) *Service {
// TODO(latenssi): safeguard against nil config?
return &Service{store, km, fc, wp, cfg}
} | func NewService(
cfg *configs.Config,
store Store,
km keys.Manager,
fc *client.Client,
wp *jobs.WorkerPool,
) *Service {
// TODO(latenssi): safeguard against nil config?
return &Service{store, km, fc, wp, cfg}
} | func NewService(db *sql.DB) Service {
return service{NewRepository(db), membership.NewService(db), db}
} | func NewService(cli client.Client) *Repository {
idIndex := model.ByEquality("id")
idIndex.Unique = true
idIndex.Order.Type = model.OrderTypeUnordered
slugIndex := model.ByEquality("slug")
slugIndex.Unique = true
slugIndex.Order.Type = model.OrderTypeUnordered
return &Repository{
Tags: tags.NewTagsServ... | func NewService(host string) *Service {
defaultHeaders := map[string]string{"User-Agent": "engine-api-cli-1.0"}
dc, err := client.NewClient(host, dockerApiVersion, nil, defaultHeaders)
if err != nil {
logPrintf(err.Error())
}
CachedServices = make(map[string]SwarmService)
return &Service{
Host: host,
... | func NewService(r repository.Repository) Service {
return service{r}
} | func newRandomNumberService(appConfig *config.AppConfig) *services.DefaultRandomNumberService {
return &services.DefaultRandomNumberService{
}
} | func NewService(r Repository) Service {
return &service{r}
} | func NewService(config *models.ServiceConfig) *Service {
return &Service{
config: config,
forever: make(chan struct{}),
}
} | func NewService(categories Repository, ws wiki.Service) Service {
return &service{
categories: categories,
wikiService: ws,
}
} | func NewService() *Service {
return &Service{
wf: aw.New(),
}
} | func NewChessService(l logrus.Entry) pb.ChessApplicationServer {
return &chessService{l}
} | func NewService(localDB *Database, sumDB *client.SumDBClient, height int) *Service {
rf := &compact.RangeFactory{
Hash: func(left, right []byte) []byte {
var lHash, rHash tlog.Hash
copy(lHash[:], left)
copy(rHash[:], right)
thash := tlog.NodeHash(lHash, rHash)
return thash[:]
},
}
return &Service{... | func newServiceForCR(cr *appv1alpha1.GontadorService, name string, port int32) *corev1.Service {
labels := map[string]string{
"app": cr.Name,
}
svc :=
&corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: cr.Name + "-svc",
Namespace: cr.Namespace,
Labels: labels,
},
Spec: corev1.Serv... | func SocketServiceNew() (return__ *SocketService) {
var __cgo__return__ interface{}
__cgo__return__ = C.g_socket_service_new()
if __cgo__return__ != nil {
return__ = NewSocketServiceFromCPointer(unsafe.Pointer(reflect.ValueOf(__cgo__return__).Pointer()))
}
return
} | func NewService(r repository) Service {
return &service{r}
} | func New(service proxy) *Consumer {
return &Consumer{
service: service,
}
} | func NewService(c Config) (*Service, error) {
// Use defaults where necessary.
d := c.WithDefaults()
s := Service{
bindAddress: d.BindAddress,
database: d.Database,
retentionPolicy: d.RetentionPolicy,
protocol: d.Protocol,
batchSize: d.BatchSize,
batchPending: d.BatchPending,
... | func NewService(player Player, prayerDatabase PrayerDatabase) *Service {
return &Service{
player: player,
prayerDatabase: prayerDatabase,
}
} | func New(fs afs.Service) trigger.Service {
return &service{Service:fs}
} | func NewService(scope *actuators.Scope) *Service {
// create the transport
transport := httptransport.New(os.Getenv("TODOLIST_HOST"), "", nil)
// create the API client, with the transport
client := apiclient.New(transport, strfmt.Default)
return &Service{
scope: scope,
airshipclient: client,
}
} | func NewService(tr transport.Doer) *Service {
return &Service{tr}
} | func newDBServiceForCR(cr *wordpressv1alpha1.Wordpress) *corev1.Service {
labels := map[string]string{
"app": cr.Name + "-db",
}
return &corev1.Service{
ObjectMeta: metav1.ObjectMeta{
Name: cr.Name + "-db",
Namespace: cr.Namespace,
Labels: labels,
},
Spec: corev1.Service... | func NewService(
repository Repository,
blockService mined_blocks.Service,
trService transfer_link.Service,
) Service {
adapter := NewAdapter()
return createService(adapter, repository, blockService, trService)
} | func NewService(program string, args ...string) *service {
log.Println("NewLocal service")
return &service{
program: program,
args: args,
}
} | func NewAPICfgService(m *macaron.Macaron) error {
bind := binding.Bind
m.Group("/api/cfg/services", func() {
m.Get("/", login.ReqSignedIn, GetServiceCfg)
m.Post("/", login.ReqSignedIn, bind(config.ServiceCfg{}), AddServiceCfg)
m.Put("/:id", login.ReqSignedIn, bind(config.ServiceCfg{}), UpdateServiceCfg)
m.D... | func NewService(token string) *Service {
return &Service{
Token: token,
}
} | func NewService(db *sql.DB) ServiceInterface {
return &Service{
vr: NewRepo(db),
}
} | func NewService(r *repository.Repository) *Service {
return &Service{r}
} | func NewService(userCol *user.Collection) *Service {
return &Service{userCol}
} | func NewService(c Config) Service {
return Service{
config: c,
}
} | func NewService(corpus *maintner.Corpus) issues.Service {
return service{
c: corpus,
}
} | func NewService(homeID string, items item.Service, users user.Service) Service {
return &service{homeID, items, users}
} | func NewService(db *gorm.DB) Service {
return &service{
db: db,
}
} | func NewService(repo Repository) Service {
return service{repo}
} | func NewService(protoPackage string, descriptor *descriptorpb.ServiceDescriptorProto) *protomodel.Service {
// might need *descriptor.ProtoReflect().Type() to instantiate Go type and then reflect to get the name?
service := &protomodel.Service{
Descriptor: descriptor,
Name: *descriptor.Name,
TypeName:... | func NewService() *Service {
app := &Service{}
c := config.Parse()
switch c.DBType {
case 1:
app.database = &db.FileDB{Path: c.DBUri}
default:
app.database = &db.FileDB{Path: c.DBUri}
}
app.log = &log.StdOutLog{Out: c.Log}
app.ctx = context.Background()
app.readConnPoll = make(chan db.DB, 4*10)
app.writeC... | func NewService(repo Repository) Service {
return Service{repo}
} | func newService(t *testing.T, server rest.Server, name string, ready bool) *serviceX {
svc := &serviceX{
t: t,
server: server,
name: name,
ready: ready,
}
return svc
} | func newService(opts ...Option) (service, error) {
if len(opts) == 0 {
return nil, errors.New(errors.KsiInvalidArgumentError)
}
f := factory{}
if err := f.initialize(opts...); err != nil {
return nil, err
}
// Only one service can be constructed.
if (f.srv != nil && f.ha != nil) ||
(f.srv == nil && f.ha ... | func NewService(db db.DB) Service {
return &service{db}
} | func NewService(beatPortClient domain.BeatPortClient) *service {
return &service{
beatPortClient: beatPortClient,
}
} | func newService(opts *ServiceOptions) (service.Service, error) {
if opts == nil {
opts = defaultServiceOpts
}
// TODO: Add hosts's username
svcConfig := &service.Config{
Name: "klient",
DisplayName: "klient",
Description: "Koding Service Connector",
Executable: filepath.Join(KlientDirectory, "kli... | func NewService(dR Repository, cR cards.Repository) Service {
return &service{dR, cR}
} | func NewService(repository gopher.Repository) Service {
return &service{repository}
} | func NewService(repository gopher.Repository) Service {
return &service{repository}
} | func NewService() *Service {
return &Service{
repo: repository.NewRepository(),
}
} | func NewService(
router router.Router,
hk *hook.Hooks,
rep repository.Repository,
maxQueueSize int,
logger kitlog.Logger,
) *Service {
return &Service{
router: router,
hk: hk,
rep: rep,
maxQueueSize: maxQueueSize,
logger: logger,
}
} | func NewService(r Repository, e EncryptionService, u *user.Service,
p *page.Service) *Service {
return &Service {
repo: r,
encryption: e,
userService: u,
pageService: p,
}
} | func newWikiService(rpc RpcClient) (*WikiService, error) {
if rpc == nil {
return nil, errors.New("rpc client cannot be nil")
}
return &WikiService{
rpc: rpc,
}, nil
} | func New() Service {
return service{}
} | func NewService(vendor string, product string, version string, url string) (*Service, error) {
s := Service{
vendor: vendor,
product: product,
version: version,
url: url,
interfaces: make(map[string]dispatcher),
descriptions: make(map[string]string),
}
err := s.RegisterInterfac... | func newNodeService(instanceID string) nodeService {
cloud, err := cloud.NewCloud()
if err != nil {
panic(err)
}
return nodeService{
cloud: cloud,
mounter: newNodeMounter(),
volumeLocks: gcpcommon.NewVolumeLocks(),
instanceID: instanceID,
}
} | func NewService(repo Repository) Service {
return &postService{
repo,
}
} | func newLocalService(env evergreen.Environment) *localService {
return &localService{env: env}
} | func New(batchURLProvider func(rule *config.Rule) string, storageService afs.Service) Service {
return &service{
taskURLProvider: batchURLProvider,
fs: storageService,
}
} | [
"0.6719757",
"0.6419366",
"0.6400057",
"0.63199586",
"0.6150302",
"0.6110697",
"0.5925688",
"0.59092116",
"0.5908589",
"0.5904497",
"0.5849958",
"0.5836222",
"0.5827284",
"0.57843095",
"0.57813245",
"0.57773834",
"0.575127",
"0.5735819",
"0.5732295",
"0.57089144",
"0.56772",
... |
AddEntry adds one entry to one or more existing boards. | func (s *BoardService) AddEntry(BoardIDs []string, entryID string) (*http.Response, error) {
bodyJSON := &struct {
EntryID string `json:"entryId,omitempty"`
}{
EntryID: entryID,
}
apiError := new(APIError)
resp, err := s.sling.New().Put("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).BodyJSON(bodyJSON).... | func (client *SBClient) AddEntry(entry string) error {
roomName := client.config.Room
headers := make(map[string]string)
headers["Entry-Text"] = entry
response, err := client.call(http.MethodPost, "/gameplay/"+roomName, nil, headers)
if err != nil {
return fmt.Errorf("error during http request: %e", err)
}
swi... | func (game *Game) AddEntry(entry string, issuer string) error {
if issuer != game.Turn {
return errors.New("invalid entry - not this player's turn")
}
if game.MaxLength > 0 && len(entry) > game.MaxLength {
return fmt.Errorf("invalid entry - entry is above max length (%v)", game.MaxLength)
}
game.Story = appen... | func (c *Clipboard) AddEntry(con string) error {
entries := c.Entries
if len(entries) > 0 {
lastEntry := entries[len(entries)-1]
newID := lastEntry.ID + 1
entries = append(entries, Entry{
ID: newID,
Content: con,
Time: fmt.Sprintf("%s", time.Now().Format("Mon Jan _2 15:04:05 2006")),
})
} el... | func AddEntry(entries ...any) {
mu.Lock()
defer mu.Unlock()
addEntries(entries...)
} | func (wlt *Wallet) AddEntry(entry Entry) error {
// dup check
for _, e := range wlt.Entries {
if e.Address == entry.Address {
return errors.New("duplicate address entry")
}
}
wlt.Entries = append(wlt.Entries, entry)
return nil
} | func (h *HostsAPI) AddEntry(entry *HostEntry) error {
if _, exists := h.entries[entry.Hostname]; exists {
return fmt.Errorf("failed to add entry, hostname already exists: %s", entry.Hostname)
}
h.entries[entry.Hostname] = entry
return nil
} | func (db *MemDb) AddEntry(e Entry) Entry {
log.Println("AddEntry", e)
return db.AddGroupEntry("", e)
} | func (rb *ReceiptBuilder) AddEntry(entry *MigratedFundsEntry) *ReceiptBuilder {
rb.r.Funds = append(rb.r.Funds, entry)
return rb
} | func (g *Boards) Add(w http.ResponseWriter, r *http.Request) {
// Obtain Board Meta.
meta := new(typ.BoardMeta)
meta.SubmissionAddresses =
strings.Split(r.FormValue("submission_addresses"), ",")
meta.Trim()
// Generate board.
board := &typ.Board{
Name: r.FormValue("name"),
Desc: r.FormValue("description"),... | func (db *DB) AddEntry(date string, text string) {
if _, ok := db.entries[date]; !ok {
db.entries[date] = []string{text}
return
}
db.entries[date] = append(db.entries[date], text)
} | func AddEntry(db *sql.DB, jd string, je string) {
rows, err := db.Query(`SELECT * FROM journal_entries WHERE date = ?`, jd)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
dateExists := false
for rows.Next() {
err := rows.Scan(&dbid, &dbdate, &dbentry)
if err != nil {
log.Fatal(err)
}
if jd == ... | func (e *EntryList) AddEntry(item entry) {
stack := []entry{item}
for len(stack) > 0 {
topEntry := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if entries := topEntry.trySplitInDifferentDays(); len(entries) > 0 {
stack = append(stack, entries...)
continue
}
if entries := topEntry.trySplitAfter9... | func (s *BoardService) AddMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Put("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).... | func (un *UnbondingNode) AddEntry(creationHeight int64,
minTime time.Time, balance sdk.Int) {
entry := NewUnbondingNodeEntry(creationHeight, minTime, balance)
un.Entries = append(un.Entries, entry)
} | func (runner *runner) AddEntry(entry string, set string, ignoreExistErr bool) error {
args := []string{"add", set, entry}
if ignoreExistErr {
args = append(args, "-exist")
}
if _, err := runner.exec.Command(IPSetCmd, args...).CombinedOutput(); err != nil {
return fmt.Errorf("error adding entry %s, error: %v", e... | func (g *BoardsMetaSubmissionAddresses) Add(w http.ResponseWriter, r *http.Request) {
bpk, e := misc.GetPubKey(r.FormValue("board"))
if e != nil {
send(w, e.Error(), http.StatusBadRequest)
return
}
address := r.FormValue("address")
if address == "" {
send(w, "no submission address provided", http.StatusBadRe... | func (c *Client) AddEntry(link, title, content string) error {
if c.baseURL == "" || c.apiKey == "" {
return fmt.Errorf("nunux-keeper: missing credentials")
}
doc := &Document{
Title: title,
Origin: link,
Content: content,
ContentType: "text/html",
}
apiURL, err := getAPIEndpoint(c.baseU... | func (g *GuestBook) AddEntry(email, title, content string) int {
// Acquire our lock and make sure it will be released.
g.mutex.Lock()
defer g.mutex.Unlock()
// Get an id for this entry.
newId := len(g.guestBookData)
// Create new entry with the given data and the computed newId.
newEntry := &GuestBookEntry{
... | func (tbl *FDB) AddEntry(vnid uint32, mac net.HardwareAddr, rdst net.IP) {
loc := -1
tbl.mu.RLock()
hkey := hmackey(vnid, mac)
if _, ok := tbl.entries[hkey]; !ok {
tbl.entries[hkey] = map[int]*FDBEntry{}
}
for k, entry := range tbl.entries[hkey] {
if entry.vnid == vnid && bytes.Compare(entry.mac, mac) == ... | func (h *Hostsfile) AddEntry(host *Host) error {
defer h.File.Seek(0, 0)
// Go the end of the file to append the new host entry.
h.File.Seek(0, 2)
entry := fmt.Sprintf(entryTemplate, host.IP, host.Hostname, host.Id)
if _, err := h.File.WriteString(entry); err != nil {
return errors.New("Unable to write entry ... | func (file *File) AddEntry(e *Entry) {
if file.entries == nil {
file.entries = map[string]*Entry{}
}
file.entries[e.Key()] = e
if e.isHeader() {
file.initHeader()
file.initPlural()
}
} | func (it *Release) AddEntry(entry *SemanticCommit) {
it.Commits = append(it.Commits, entry)
} | func (sr *RequestBuilder) AddEntry(data Entry) *RequestBuilder {
sr.Data = data
return sr
} | func (st secretStore) AddEntry(e StoreEntry, id string) string {
e.DateAdded = time.Now()
if id == "" {
id = hashStruct(e)
}
if e.ValidFor == 0 {
e.ValidFor = defaultValidity
}
if e.MaxClicks == 0 {
e.MaxClicks = defaultMaxClicks
}
st[id] = e
return id
} | func AddEntry(ctx context.Context, parentID, spiffeID, selector, federatesWith string) error {
cmdStr := "spire-server entry create -parentID %s -spiffeID %s -selector %s"
cmdStr = fmt.Sprintf(cmdStr, parentID, spiffeID, selector)
if federatesWith != "" {
cmdStr = fmt.Sprintf(cmdStr+" -federatesWith %s", federates... | func (b *Buffer) AddEntry(e *Entry) error {
if b.sitemap.IsFull() {
err := b.Flush()
if err != nil {
return err
}
}
if b.sitemap == nil {
b.sitemap = NewSitemap()
}
b.sitemap.Entries = append(b.sitemap.Entries, e)
return nil
} | func (s *Mysql) AddServerEntry(data Servers) error {
r := s.client.First(&Servers{}, "name = ?", data.Name)
if r.RowsAffected != 0 {
return errors.New("already exists")
} else if r.Error != nil && r.RowsAffected != 0 {
return r.Error
}
result := s.client.Create(&Servers{
Name: data.Name,
DisplayNa... | func (r *PlaylistRepo) AddEntry(playlistID uint, entry *models.PlaylistEntry) error {
query := fmt.Sprintf(
"INSERT INTO PlaylistEntries(playlistId, %s) VALUES(?, ?, -1, ?, ?, datetime('now'), datetime('now'))",
playlistEntryFields,
)
res, err := r.db.Exec(query, playlistID, entry.VideoHash, entry.RequestedBy, e... | func AddEntry(name, iface string, port int) error {
return add(getSSHConfigPath(), buildHostname(name), iface, port)
} | func (st *Table) AddEntry(symbol string, addr int16) {
st.table[symbol] = addr
} | func (lex *MorphologicalLexicon) AddEntry(form, lemma, tag string) {
form = strings.ToLower(form)
list := lex.entries[form]
list = append(list, &LexicalEntry{lemma, tag})
lex.entries[form] = list
} | func (l *ChatLogger) AddEntry(user string, message string) error {
if !l.Connected {
return errors.New("log client is not running")
}
entry := LogEntry{User: user, Message: message, Timestamp: time.Now().Format(time.RFC3339Nano)}
_, err := l.Client.Index().Index(logIndex).Type("doc").BodyJson(entry).Do(context.B... | func (s *UnifiedSorter) AddEntry(ctx context.Context, entry *model.PolymorphicEvent) {
select {
case <-ctx.Done():
return
case s.inputCh <- entry:
}
} | func (l *LayerWriter) AddEntry(realPath string, inImagePath string, info os.FileInfo, whiteout bool) (err error) {
return l.archiveWriter.AddEntry(realPath, inImagePath, info, whiteout)
} | func (index *Index) AddEntry(chartVersion *helm_repo.ChartVersion) {
if _, ok := index.Entries[chartVersion.Name]; !ok {
index.Entries[chartVersion.Name] = helm_repo.ChartVersions{}
}
//
entries := index.Entries[chartVersion.Name]
l := len(entries)
for i := 1; i <= 5 && l-i >= 0; i++ {
cv := entries[l-i]
if... | func addNewEntry(w http.ResponseWriter, r *http.Request) {
label, _ := ioutil.ReadAll(r.Body)
newEntries, err := model.CreateNew(string(label))
if err != nil {
fmt.Fprintf(w, "Error adding new entry: %v", err)
return
}
if json.NewEncoder(w).Encode(newEntries) != nil {
fmt.Fprintf(w, "Error pars... | func (t *NetworkInstance_Fdb_MacTable) AppendEntry(v *NetworkInstance_Fdb_MacTable_Entry) error {
key := NetworkInstance_Fdb_MacTable_Entry_Key{MacAddress: *v.MacAddress, Vlan: *v.Vlan}
// Initialise the list within the receiver struct if it has not already been
// created.
if t.Entry == nil {
t.Entry = make(map... | func (c *Connection) Add(entry feedback.Entry) (err error) {
c.Debug("adding entry",
zap.String("session", entry.SessionID),
zap.String("user", entry.UserID),
)
defer func() {
err = handleError(err)
}()
query := "INSERT INTO entries(session_id, user_id, rating, comment) VALUES ($1, $2, $3, $4)"
statement, ... | func (p *Palette) Add(name string, e Entry) {
p.m.Lock()
defer p.m.Unlock()
p.entries[strings.ToLower(name)] = e
} | func (t *NetworkInstance_Fdb_MacTable) AppendEntry(v *NetworkInstance_Fdb_MacTable_Entry) error {
key := *v.MacAddress
// Initialise the list within the receiver struct if it has not already been
// created.
if t.Entry == nil {
t.Entry = make(map[string]*NetworkInstance_Fdb_MacTable_Entry)
}
if _, ok := t.Ent... | func (t *NetworkInstance_Fdb_MacTable) AppendEntry(v *NetworkInstance_Fdb_MacTable_Entry) error {
key := *v.MacAddress
// Initialise the list within the receiver struct if it has not already been
// created.
if t.Entry == nil {
t.Entry = make(map[string]*NetworkInstance_Fdb_MacTable_Entry)
}
if _, ok := t.Ent... | func (t *NetworkInstance_Fdb_MacTable) AppendEntry(v *NetworkInstance_Fdb_MacTable_Entry) error {
key := *v.MacAddress
// Initialise the list within the receiver struct if it has not already been
// created.
if t.Entry == nil {
t.Entry = make(map[string]*NetworkInstance_Fdb_MacTable_Entry)
}
if _, ok := t.Ent... | func (eg *EntryGroup) AddEntry(ts uint64, entry *model.RawKVEntry) {
i := sort.Search(len(eg.sortedTs), func(i int) bool { return eg.sortedTs[i] >= ts })
if i < len(eg.sortedTs) && eg.sortedTs[i] == ts {
eg.entriesMap[ts] = append(eg.entriesMap[ts], entry)
} else {
eg.sortedTs = append(eg.sortedTs, 0)
copy(eg.... | func (n *node) appendEntry(ent entry.T) {
n.payload[n.count] = ent
n.count++
} | func (s *Store) AppendEntry(arg *Action, unusedRetVal *uint64) error {
StoreChannel <- *arg
return nil
} | func (c *Conf) AppendEntry(connType, database, user, address, method string) (*generic.Row, error) {
isSpace := func(value string) bool {
return strings.TrimSpace(value) == ""
}
if isSpace(connType) || isSpace(database) || isSpace(user) || isSpace(address) || isSpace(method) {
return nil, ErrEmptyArgument
}
re... | func (list *DoublyLinkedList) AddEntry(entry *DoublyLinkedListEntry) {
list.AddLastEntry(entry)
} | func AddEntry(line *decode.CcqLine, table map[string][]string) {
table[line.Symbol] = line.Content
} | func (sfm *SafeFileMap) AddEntry(name string, size int, metafile []byte, metahash [32]byte) (isNew bool) {
sfe := NewSafeFileEntry(name, size, metafile, metahash)
_, notNew := sfm.filesMap.LoadOrStore(sfe.metahash, sfe)
return !notNew
} | func (tx *DataWithProofs) AppendEntry(entry DataEntry) error {
if len(entry.GetKey()) == 0 {
return errors.Errorf("empty keys are not allowed")
}
key := entry.GetKey()
for _, e := range tx.Entries {
if e.GetKey() == key {
return errors.Errorf("key '%s' already exist", key)
}
}
tx.Entries = append(tx.Entr... | func AddArpEntry(name string, arpEntry *netlink.Neigh, log logging.Logger, timeLog measure.StopWatchEntry) error {
log.Debugf("Creating new ARP entry %v", name)
start := time.Now()
defer func() {
if timeLog != nil {
timeLog.LogTimeEntry(time.Since(start))
}
}()
return netlink.NeighAdd(arpEntry)
} | func AddEntry(what string) error {
return AddEntryToBucket(rootBucketName, what)
} | func (rf *Raft) addEntry(command interface{},term int) {
rf.log = append(rf.log,Command{command,term})
} | func (f *File) Add(entry Entry) {
if err := doError(); err != nil {
fmt.Println(err)
}
} | func (view *UtxoViewpoint) addEntry(outpoint wire.OutPoint, entry *UtxoEntry, overwrite bool) error {
view.entries[outpoint] = entry
return nil
} | func (w *wheel) addEntry(interval time.Duration, job JobFunc, singleton bool, times int64, status int64) *Entry {
if times <= 0 {
times = defaultTimes
}
var (
ms = interval.Nanoseconds() / 1e6
num = ms / w.intervalMs
)
if num == 0 {
// If the given interval is lesser than the one of the wheel,
// then s... | func AddBoard(billboard Board) error {
const q = `INSERT INTO billboards(author, content, created_at) VALUES ($1, $2, $3)`
/*
db.Exec() executes query without returning any rows
*/
_, err := db.Exec(q, billboard.Author, billboard.Content, billboard.CreatedAt)
return err
} | func (r *NodeRegistry) addEntry(entry *NodeRegistryEntry) error {
for _, name := range entry.nodeKindNames {
if _, exists := r.nodeIndex[name]; exists {
return fmt.Errorf("node kind %q already registered in Node Registry", name)
}
r.nodeIndex[name] = entry
}
return nil
} | func (b *batch) add(entry entry) {
b.bytes += len(entry.Line)
// Append the entry to an already existing stream (if any)
labels := entry.labels.String()
stream, ok := b.streams[labels]
if ok {
stream.Entries = append(stream.Entries, entry.Entry)
return
}
// Add the entry as a new stream
b.streams[labels]... | func (e *Entries) NewEntry(new *Entry) {
*e = append(*e, new)
} | func (c *Client) AddClientEntry() {
fmt.Println("CLIENT ADDED IN THE REDIS STORE.")
} | func AddShareBoard(m *ShareBoard) (id int64, err error) {
o := orm.NewOrm()
id, err = o.Insert(m)
return
} | func (e *EntryHandler) HandleAddEntry(w http.ResponseWriter, r *http.Request) {
newEntry := &services.Entry{}
err := decodeAndValidate(r, newEntry)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
}
err = e.Service.AddEntry(newEntry)
if err != nil {
log.Printf("Error adding Entry to DB: %s", err.... | func (d *Dir) AddEntry(newEntry DirEntry) (err error) {
defer essentials.AddCtxTo("AddEntry", &err)
entries, err := d.ReadDir()
if err != nil {
return err
}
entries = append(entries, newEntry)
return d.WriteDir(entries)
} | func (r *NewsFeedRepository) AddEntries(ctx context.Context, entries []*newsfeed.Entry) error {
query := `
INSERT INTO newsfeed
(user_id, document_id, created_at)
VALUES
%s
`
p := getMultiInsertPlacements(len(entries), 3)
a := getFeedEntriesParameters(entries)
_, err := r.db.ExecContext(ctx, formatQuery(f... | func AddOnboarding(m *Onboarding) (id int64, err error) {
database.DB.Create(m)
database.DB.Save(m)
return
} | func (s *safeIpset) AddEntry(entry string, set *ipset.IPSet, ignoreExistErr bool) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.ipset.AddEntry(entry, set, ignoreExistErr)
} | func (p *Project) SaveNewEntry(message string, db *gorm.DB) {
db.Create(&Entry{Message: message, ProjectId: p.ID})
} | func (c *TeamClient) Add(ctx context.Context, name EntryName) error {
var tx store.Transaction = func(tc context.Context) error {
entry, err := c.getEntry(ctx, name)
if err != nil {
if err != datastore.ErrNoSuchEntity {
return err
}
entry = &Entry{Name: name.String(), Score: 1}
}
entry.Score ... | func (c *TeamClient) Entry(ctx context.Context, name EntryName) (*Entry, error) {
var entry = new(Entry)
var tx store.Transaction = func(tc context.Context) error {
var err error
entry, err = c.getEntry(tc, name)
return err
}
return entry, c.runTransaction(ctx, tx)
} | func EntryCreate(opts EntryOpts) error {
entries, err, _ := getCronEntries(opts)
if err != nil {
return fmt.Errorf("unable to add %s::%s: %s", cronEntryName, opts.Name, err)
}
var newEntries []string
var added bool
for _, line := range entries {
if strings.Contains(line, fmt.Sprintf(`# %s`, opts.Name)) {
... | func (e *EDF) Add(entry *Entry) {
entry.deadline = e.curDDL + 1/entry.Weight
e.curIndex++
entry.index = e.curIndex
heap.Push(e.pq, entry)
} | func NewEntry(w http.ResponseWriter, r *http.Request) {
var err error
db := database.SQL
user := structs.User{}
entry := structs.Entry{}
err = json.NewDecoder(r.Body).Decode(&entry)
if err != nil {
utils.JSONResponse(
http.StatusUnprocessableEntity,
structs.Response{
Message: "Error en los datos recib... | func (d *DaoWrapper) AddAppEntry(a *AppIdProp) error {
_, err := d.mysql.Exec("insert into appid_list values(?, ?, ?, ?, ?, ?)", a.AppId, a.CreatedTime, a.ApiCnt, a.ExpirationTime, a.AnalysisDuration, a.Activation)
LogInfo.Printf("add appid: %s, (%s)", a, err)
return err
} | func addEntry(t *testing.T, b backend.Backend) (string, string) {
assert := assert.New(t)
id := utils.GenerateID(5)
url := generateURL()
_, err := b.Create(id, url)
assert.NoError(err)
return id, url
} | func (C *Client) Add(id int, entry mal.AnimeEntry) error {
_, err := C.Anime.Add(id, entry)
return err
} | func (e *EBlock) AddEBEntry(entry interfaces.IEBEntry) error {
e.Body.EBEntries = append(e.Body.EBEntries, entry.GetHash())
if err := e.BuildHeader(); err != nil {
return err
}
return nil
} | func NewEntry(name string, score int) *Entry {
return &Entry{
Name: name,
Score: ScoreType(score),
Time: time.Now().UTC(),
}
} | func (ds *Dataset) addEntry(target float64, features featuresVector, gauge int) {
checkFeaturesAmount(features, gauge)
de := newDataEntry(target, features)
*ds.Data = append(*ds.Data, de)
} | func AddEntryBlock(db *database.DB, dbheight int64, keyMR string) (err error) {
// Pull the Entry Block from the Directory Block
if entryBlock, err := factom.GetEBlock(keyMR); err != nil {
return fmt.Errorf("could not pull the entry block at %s", keyMR)
} else {
// Add all the entries added to Factom for this c... | func (db *MemDb) AddGroupEntry(g string, e Entry) Entry {
log.Println("AddGroupEntry", g, e)
container := db.getContainer(g)
ind, ok := container.kvsEntries[e.Key()]
if !ok {
container.kvsEntries[e.Key()] = len(container.entries)
container.entries = append(container.entries, e)
return container.entries[len(... | func (s Selector) Add(entry common.EnvironmentEntry) error {
selectedDriver, err := s.selectDriver(entry.Driver)
if err != nil {
return err
}
exists, err := s.existsEntry(entry.Name)
if err != nil {
return err
}
if exists {
return fmt.Errorf("'%s' already exists", entry.Name)
}
return selectedDriver.A... | func (s *AnimeService) Add(animeID int, entry AnimeEntry) (*Response, error) {
return s.client.post(s.AddEndpoint.String(), animeID, entry, true)
} | func (e *Entry) AddEntry(child *Entry) {
length := len(e.entries)
if length == 0 {
e.entries = append(e.entries, child)
return
}
index := sort.Search(length, func(i int) bool {
return child.weight > e.entries[i].weight
})
if index == length {
e.entries = append(e.entries, child)
return
}
e.entries ... | func (m *mongo) Add(ctx context.Context, entry *Entry) (string, error) {
if err := validateEntry(entry); err != nil {
return "", fmt.Errorf("invalid entry: %v", err)
}
entry.ID = uuid.New().String()
err := m.session.DB(m.name).C(collection).Insert(&entry)
if err != nil {
return "", fmt.Errorf("failed inserti... | func (c *Client) AddPlanEntry(planID int, newEntry SendableEntry) (Entry, error) {
createdEntry := Entry{}
err := c.sendRequest("POST", "add_plan_entry/"+strconv.Itoa(planID), newEntry, &createdEntry)
return createdEntry, err
} | func (s *Store) InsertEntry(e *entry.Entry) {
s.entries[e.Name] = e
} | func (view *ProxyView) AddEntry(e *modifier.Entry, t int) {
n := view.Table.GetRowCount()
if e.Request != nil {
url := e.Request.URL
if len(url) > 100 {
url = string([]rune(e.Request.URL)[0:100])
}
if view.proxyfilter(e.Request.URL) {
switch t {
case 0: // request
view.Table.SetCell(n, 1, tvie... | func (hs *HeapExpiringStorage) AddEntry(entry expiry.Entry, now uint32) {
if entry.Exptime > now {
heap.Push(hs.heap, entry)
}
} | func NewEntry(ctx *pulumi.Context,
name string, args *EntryArgs, opts ...pulumi.ResourceOption) (*Entry, error) {
if args == nil {
return nil, errors.New("missing one or more required arguments")
}
if args.EntryGroupId == nil {
return nil, errors.New("invalid value for required argument 'EntryGroupId'")
}
if... | func Entry(input map[string]interface{}, conn connections.Connection) (changed bool, err error) {
var opts EntryOpts
config := &mapstructure.DecoderConfig{
WeaklyTypedInput: true,
Result: &opts,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return
}
err = decoder.Decode(inp... | func (a *Application) addAddressBookEntry(w http.ResponseWriter, r *http.Request) {
var abe AddressBookEntry
jd := json.NewDecoder(r.Body)
if err := jd.Decode(&abe); nil != err {
respondWithError(w, http.StatusBadRequest,
fmt.Sprintf("Invalid request payload (%v)", r.Body))
return
}
defer r.Body.Close()
... | func NewEntry() *Entry {
return &Entry{}
} | func (ctx *Context) Add(entry *translator.Entry) error {
plural := isPlural(entry)
key := entry.Key()
pre, ok := ctx.entries[key]
if ok {
if isPlural(pre) != plural {
return errors.Errorf(t.T("msgid '%v' is used without plural and with plural.\nLine =%v\nPrevious=%v"),
entry.MsgID, entry.MsgCmts, pre.Ms... | func AddEntry(hostname string, ip string, TTL uint64, ETCD string) {
fmt.Println("addEntry called")
var services = []*msg.Service{
{Host: ip, Key: hostname + "."},
{Host: hostname, Key: reverseIP(ip)},
}
client := etcd.NewClient([]string{ETCD})
//delete any existing entries with this name or ip address
De... | func AddEntryToBucket(bucket string, what string) error {
e := entry{
Content: []byte(what),
Timestamp: time.Now(),
}
err := store.Put(bucket, e)
if err != nil {
getLogger().WithFields(logrus.Fields{
"component": "manager",
"method": "AddEntry",
"entry": "what",
}).WithError(err).Error("fa... | func (journal *TaskJournal) AddOnBoard(uindex TaskID) error {
task, err := journal.TaskList.getTask(uindex)
if err != nil {
return err
}
task.OnBoard = true
return nil
} | func (h *DashboardHandler) Add(resource grizzly.Resource) error {
board := newDashboard(resource)
if err := postDashboard(board); err != nil {
return err
}
return nil
} | func (s *SortedDentryMap) Add(name string, entry DentAttr) {
if _, ok := s.entries[name]; !ok {
// Map does not yet contain an entry with this name. We must
// insert it in s.names at the appropriate spot.
i := sort.SearchStrings(s.names, name)
s.names = append(s.names, "")
copy(s.names[i+1:], s.names[i:])
... | func NewEntry(reference swarm.Address, metadata map[string]string) Entry {
return &manifestEntry{
reference: reference,
metadata: metadata,
}
} | [
"0.68316865",
"0.6746522",
"0.6686015",
"0.66283274",
"0.66154575",
"0.65606016",
"0.6551879",
"0.64789283",
"0.64544916",
"0.6450655",
"0.639096",
"0.6351484",
"0.627345",
"0.6234307",
"0.62231815",
"0.61505634",
"0.6142842",
"0.61411375",
"0.6128632",
"0.61141425",
"0.61083... |
AddMultipleEntries adds one or more entries to one or more existing boards. | func (s *BoardService) AddMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Put("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).... | func (r *NewsFeedRepository) AddEntries(ctx context.Context, entries []*newsfeed.Entry) error {
query := `
INSERT INTO newsfeed
(user_id, document_id, created_at)
VALUES
%s
`
p := getMultiInsertPlacements(len(entries), 3)
a := getFeedEntriesParameters(entries)
_, err := r.db.ExecContext(ctx, formatQuery(f... | func (s *BoardService) AddEntry(BoardIDs []string, entryID string) (*http.Response, error) {
bodyJSON := &struct {
EntryID string `json:"entryId,omitempty"`
}{
EntryID: entryID,
}
apiError := new(APIError)
resp, err := s.sling.New().Put("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).BodyJSON(bodyJSON).... | func AddEntry(entries ...any) {
mu.Lock()
defer mu.Unlock()
addEntries(entries...)
} | func (r raftAPI) AppendEntries(id raft.ServerID, target raft.ServerAddress, args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) error {
c, err := r.getPeer(id, target)
if err != nil {
return err
}
ret, err := c.AppendEntries(context.TODO(), encodeAppendEntriesRequest(args))
if err != nil {
retur... | func (s *BoardService) DeleteMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, "... | func (s *Server) AppendEntries(ctx context.Context, in *pb.AppendEntriesRequest) (*pb.AppendEntriesResponse, error) {
replyChan := make(chan pb.AppendEntriesResponse)
event := Event {
rpc: RpcEvent{
appendEntries: &RaftAppendEntriesRpcEvent{
request: *in,
responseChan: replyChan,
},
},
}
raftServe... | func (sm *StateMachine) AppendEntries(ctx context.Context, req *konsen.AppendEntriesReq) (*konsen.AppendEntriesResp, error) {
ch := make(chan *konsen.AppendEntriesResp)
sm.msgCh <- appendEntriesWrap{req: req, ch: ch}
select {
case <-ctx.Done():
return nil, ctx.Err()
case resp := <-ch:
return resp, nil
}
} | func AddMultiTraces(mlist []*Traces) (err error) {
o := orm.NewOrm()
_, err = o.InsertMulti(20, mlist)
return
} | func (r *RaftTransport) AppendEntries(id raft.ServerID, target raft.ServerAddress, args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) error {
return r.genericRPC(id, target, rpcAppendEntries, args, resp)
} | func (r *Replica) AppendEntries(stream pb.Raft_AppendEntriesServer) (err error) {
// Keep receiving messages on the stream and sending replies after each
// message is sent on the stream.
for {
var in *pb.AppendRequest
if in, err = stream.Recv(); err != nil {
if err == io.EOF {
return nil
}
return ... | func (sc *AutumnStreamClient) AppendEntries(ctx context.Context, entries []*pb.EntryInfo) (uint64, uint32, error) {
if len(entries) == 0 {
return 0, 0, errors.Errorf("blocks can not be nil")
}
blocks := make([]*pb.Block, 0, len(entries))
for _, entry := range entries {
data := utils.MustMarshal(entry.Log)
b... | func (rf *Raft) AppendEntries(
args AppendEntriesArgs,
reply *AppendEntriesReply,
) {
rf.mu.Lock()
defer rf.mu.Unlock()
term, _ := rf.TermRoleHolder().CurrentTermRole()
if args.LeaderTerm < term {
// Reject an out-of-date leader.
reply.Concatenable = false
reply.TermHold = term
return
}
rf.termRoleHol... | func (rf *Raft) AppendEntries(args *AppendEntriesArgs, reply *AppendEntriesReply) {
rf.evaluateTerm(args.Term)
rf.mu.Lock()
defer rf.mu.Unlock()
reply.Succes = true
reply.Term = rf.term
reply.Conflict = args.PreviousIndex
if args.Term < rf.term {
reply.Succes = false
return
}
if args.PreviousIndex < rf.l... | func (rf *Raft) AppendEntries(args *AppendEntriesArgs, reply *AppendEntriesReply) {
rf.mu.Lock()
defer rf.mu.Unlock()
reply.Term = rf.CurrentTerm
if (args.Term < rf.CurrentTerm) {
// stale leader --> then reply false
reply.Success = false
return
}
if (args.Entries == nil) {
// receiving heartbeat from lea... | func (d *director) AppendEntries(ctx context.Context, in *AppendEntriesRequest) (*AppendEntriesReply, error) {
// append to log
// TODO some kind of error
return &AppendEntriesReply{}, nil
} | func (r *RPC) AppendEntriesRPC(args AppendRPCArgs, reply *AppendRPCResults) error {
//Send to event channel of this server
responseCh := make(chan AppendRPCResults, 5)
raft.eventCh <- AppendRPC{args, responseCh}
*reply = <-responseCh
return nil
} | func (c *Configuration) AppendEntries(ctx context.Context, arg *raftpb.AppendEntriesRequest, perNode func(arg raftpb.AppendEntriesRequest, nodeID uint32) *raftpb.AppendEntriesRequest) (*raftpb.AppendEntriesQFResponse, error) {
return c.appendEntries(ctx, arg, perNode)
} | func (c *Client) AddEntityEntries(eidOrName string, entries []EntityEntryObject) (result ApiResponse, err error) {
var bytes []byte
if bytes, err = c.httpPost(fmt.Sprintf("entities/%s/entries", eidOrName), nil, nil, entries); err == nil {
if err = json.Unmarshal(bytes, &result); err == nil {
return result, nil
... | func (t *Raft) AppendEntries(log *LogEntry, reply *int) {
generateRandomTimeoutCounter()
if log != nil {
logs = append(logs, *log)
}
*reply = 200 // return okay
return nil
} | func (n *Node) AppendEntries(req *AppendEntriesRequest) (*AppendEntriesReply, error) {
n.Debug("AppendEntries request received")
// Ensures that goroutine is not blocking on sending msg to reply channel
reply := make(chan AppendEntriesReply, 1)
n.appendEntries <- AppendEntriesMsg{req, reply}
select {
case <-n.ctx... | func (rp *raftPipeline) AppendEntries(args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) (raft.AppendFuture, error) {
future := &appendFuture{
start: time.Now(),
args: args,
resp: resp,
}
future.init()
cmd, _ := msgpack.Marshal(future.args)
err := rp.server.SendMsg(rp.conn, &volumesAPI.Pe... | func (e *EntryList) AddEntry(item entry) {
stack := []entry{item}
for len(stack) > 0 {
topEntry := stack[len(stack)-1]
stack = stack[:len(stack)-1]
if entries := topEntry.trySplitInDifferentDays(); len(entries) > 0 {
stack = append(stack, entries...)
continue
}
if entries := topEntry.trySplitAfter9... | func (t *eventTransport) AppendEntries(
id raft.ServerID, target raft.ServerAddress, args *raft.AppendEntriesRequest,
resp *raft.AppendEntriesResponse) error {
peer := t.peers.Get(id)
t.logger.Debug(fmt.Sprintf("[DEBUG] raft-test: server %s: transport: append to %s: %s", t.id, id, stringifyLogs(args.Entries)))
/... | func (rf *Raft) AppendEntries(args *AppendEntriesArgs, reply *AppendEntriesReply) {
// Your code here (2A, 2B).
rf.mu.RLock()
currentTerm := rf.currentTerm
rf.mu.RUnlock()
// Match term no.
if args.Term < currentTerm {
reply.Term = currentTerm
reply.Success = false
return
} else if args.Term > currentT... | func (s *server) AppendEntries(req *AppendEntriesRequest) *AppendEntriesResponse {
ret, _ := s.send(req)
resp, _ := ret.(*AppendEntriesResponse)
return resp
} | func (t *Libp2pTransport) AppendEntries(target string, args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) error {
err := t.makeRPC(t.ctx, target, rpcAppendEntries, args, resp)
if err != nil {
return err
}
return nil
} | func (sm *StateMap) AddMany(entries []State, attempts, max int) error {
attempts++
retry := make([]State, 0)
for _, entry := range entries {
err := sm.Add(entry)
if err != nil {
retry = append(retry, entry)
}
}
if len(retry) >= 1 {
if attempts > max {
return fmt.Errorf("Unable to load %d states: %s",... | func (server *RaftServer) AppendEntries(args *AppendEntryArgs, reply *AppendEntryReply) error {
if args.term < server.currentTerm {
reply.term = server.currentTerm
} else {
server.currentTerm = args.term
server.leaderId = args.leaderId
server.state = FOLLOWER
reply.term = server.currentTerm
}
return nil
} | func (rf *Raft) AppendEntries(args AppendEntriesArgs, reply *AppendEntriesReply) {
if rf.currentTerm <= args.Term {
rf.currentTerm = args.Term
rf.role = FOLLOWER
rf.ResetElectionTimeout()
}
// Include the server term in the reply
reply.Term = rf.currentTerm
} | func (s *BatchGrantPermissionsInput) SetEntries(v []*BatchPermissionsRequestEntry) *BatchGrantPermissionsInput {
s.Entries = v
return s
} | func (s *Slice) AppendEntries(o []byte, args [][]byte) ([]byte, error) {
return s.transport.handleAppendEntries(o, args)
} | func (s *PutPartnerEventsInput) SetEntries(v []*PutPartnerEventsRequestEntry) *PutPartnerEventsInput {
s.Entries = v
return s
} | func (v *ActionMap) AddActionEntries(entries []ActionEntry, user_data interface{}) {
gEntries := make([]C.GActionEntry, len(entries))
for i := 0; i < len(entries); i++ {
gEntries[i].name = (*C.gchar)(C.CString(entries[i].Name))
defer C.free(unsafe.Pointer(gEntries[i].name))
if len(entries[i].ParameterType) == 0... | func (r raftPipelineAPI) AppendEntries(req *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) (raft.AppendFuture, error) {
af := &appendFuture{
start: time.Now(),
request: req,
done: make(chan struct{}),
}
if err := r.stream.Send(encodeAppendEntriesRequest(req)); err != nil {
return nil, err
... | func (s *PutEventsInput) SetEntries(v []*PutEventsRequestEntry) *PutEventsInput {
s.Entries = v
return s
} | func (p *EpAll) CreateEntries(entries ...upstream.Entry) ([]upstream.Entry, error) {
if len(entries) == 0 {
return nil, fs.ErrorObjectNotFound
}
entries = filterNCEntries(entries)
if len(entries) == 0 {
return nil, fs.ErrorPermissionDenied
}
return entries, nil
} | func (e *DiscoveryChainConfigEntries) AddEntries(entries ...ConfigEntry) {
for _, entry := range entries {
switch entry.GetKind() {
case ServiceRouter:
e.AddRouters(entry.(*ServiceRouterConfigEntry))
case ServiceSplitter:
e.AddSplitters(entry.(*ServiceSplitterConfigEntry))
case ServiceResolver:
e.AddR... | func (s *BatchRevokePermissionsInput) SetEntries(v []*BatchPermissionsRequestEntry) *BatchRevokePermissionsInput {
s.Entries = v
return s
} | func (rf *Raft) AppendEntries(args AppendEntriesArgs, reply *AppendEntriesReply) {
// Your code here.
rf.mu.Lock()
reply.Term = rf.currentTerm
// Reply false if term < currentTerm
if args.Term < rf.currentTerm{
reply.Success = false
rf.persist()
rf.mu.Unlock()
return
}
if args.Term > rf.currentTerm {
r... | func (s *PutPartnerEventsOutput) SetEntries(v []*PutPartnerEventsResultEntry) *PutPartnerEventsOutput {
s.Entries = v
return s
} | func (s *PutEventsOutput) SetEntries(v []*PutEventsResultEntry) *PutEventsOutput {
s.Entries = v
return s
} | func (rf *Raft) AppendEntries(args AppendEntriesArgs, reply *AppendEntriesReply) {
defer rf.persist()
if args.Term < rf.term {
rf.logln(fmt.Sprintf("stale sender detected, ignore append entries request. sender term = %v", args.Term))
reply.Term = rf.term
reply.Success = false
return
}
if args.Term > rf.te... | func (p *eventPipeline) AppendEntries(
args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) (raft.AppendFuture, error) {
p.logger.Debug(fmt.Sprintf("[DEBUG] raft-test: server %s: pipeline: append to %s: %s", p.source, p.target, stringifyLogs(args.Entries)))
peer := p.peers.Get(p.target)
faulty := fa... | func AddMultiTerminals(mlist []*Terminals) (err error) {
o := orm.NewOrm()
_, err = o.InsertMulti(20, mlist)
return
} | func (p *libp2pPipeline) AppendEntries(args *raft.AppendEntriesRequest, resp *raft.AppendEntriesResponse) (raft.AppendFuture, error) {
// Create a new future
future := &appendFuture{
start: time.Now(),
args: args,
resp: resp,
}
future.init()
// Send this request
logger.Debugf("%s: Appending request to pi... | func (group OptionGroup) AddEntries(entries OptionEntry) {
C.g_option_group_add_entries(group.native(), entries.native())
} | func (s *Set) AddMultiple(values []string) {
for _, value := range values {
s.add(value)
}
} | func (r *Range) Append(entries []raftpb.Entry) error {
batch := r.rm.Engine().NewBatch()
defer batch.Close()
for _, ent := range entries {
err := engine.MVCCPutProto(batch, nil, engine.RaftLogKey(r.Desc().RaftID, ent.Index),
proto.ZeroTimestamp, nil, &ent)
if err != nil {
return err
}
}
// TODO(bdarne... | func (s *RuneSet) AddMulti(list ...rune) {
for _, v := range list {
s.Add(v)
}
} | func (s *RuneSet) AddMulti(list ...rune) {
for _, v := range list {
s.Add(v)
}
} | func (log *LogManager) appendEntries(index uint64, term uint64, committed uint64, entries ...pb.Entry) (uint64, bool) {
if log.matchLog(index, term) {
// index which log does not have, entries from startIndex are new
startIndex := log.findConflict(entries)
switch {
case startIndex =... | func (node *Node) AppendEntries() {
err := node.Connect()
if err != nil {
return
}
defer func() {
if r := recover(); r != nil {
log.Printf("Panicked with node %v\n", node)
log.Fatal(r)
}
}()
entries := []Entry{}
if len(node.server.log) > 0 {
for _, entry := range node.server.log[node.nextIndex:] ... | func (raft *Raft) AppendEntriesRPC(message *RPCMessage, reply *bool) error {
/*
//case 1 - term is less than cyurrent term //TODO: to be implemented
//case 2 - if follower contains entry @ previousLeaderLogIndex with same term then OK
if raft.LogEntryBuffer[len(raft.LogEntryBuffer)-1].Lsn() >= message.LeaderPr... | func (shoes *Shoes) Add(newShoes ...GitHubIssue) (err error) {
for _, shu := range newShoes {
err = shoes.add(shu)
if err != nil {
return
}
}
return
} | func (p *GoogleCloudOutput) ProcessMulti(ctx context.Context, entries []*entry.Entry) error {
pbEntries := make([]*logpb.LogEntry, 0, len(entries))
for _, entry := range entries {
pbEntry, err := p.createProtobufEntry(entry)
if err != nil {
p.Errorw("Failed to create protobuf entry. Dropping entry", zap.Any("e... | func (dm *dirMap) addEntries(entries fs.DirEntries) error {
dm.mu.Lock()
defer dm.mu.Unlock()
for _, entry := range entries {
switch x := entry.(type) {
case fs.Object:
dm.add(parentDir(x.Remote()), false)
case fs.Directory:
dm.add(x.Remote(), true)
default:
return fmt.Errorf("unknown object type %T... | func (rf *Raft) AppendEntries(args *AppendEntriesArgs, reply *AppendEntriesReply) {
rf.mu.Lock()
defer rf.mu.Unlock()
// Set reply
reply.Term = rf.CurrentTerm
reply.Success = false
reply.Xterm = 0
reply.XIndex = 0
reply.XLen = len(rf.Log)
// Receives stale term request
if rf.CurrentTerm > args.Term {
retu... | func (uc utxoCollection) addMultiple(collectionToAdd utxoCollection) {
for outpoint, entry := range collectionToAdd {
uc[outpoint] = entry
}
} | func CreateEntries(addrs []string) (Entries, error) {
entries := Entries{}
if addrs == nil {
return entries, nil
}
for _, addr := range addrs {
if len(addr) == 0 {
continue
}
entry, err := NewEntry(addr)
if err != nil {
return nil, err
}
entries = append(entries, entry)
}
return entries, nil
... | func (puo *ProjectUpdateOne) AddRuns(r ...*Run) *ProjectUpdateOne {
ids := make([]string, len(r))
for i := range r {
ids[i] = r[i].ID
}
return puo.AddRunIDs(ids...)
} | func (c *grpcClient) AppendEntriesRPC(leaderID string, commitIndex uint64, term uint64, entries []*a.Entry,
lastEntry *a.Entry, lastIndex uint64, lastTerm uint64) (bool, uint64, error) {
msgEntries := make([]*Entry, len(entries), len(entries))
for i, entry := range entries {
msgEntries[i] = convertToPbEntry(entry)... | func (r *RDB) WriteSchedulerEntries(schedulerID string, entries []*base.SchedulerEntry, ttl time.Duration) error {
var op errors.Op = "rdb.WriteSchedulerEntries"
ctx := context.Background()
args := []interface{}{ttl.Seconds()}
for _, e := range entries {
bytes, err := base.EncodeSchedulerEntry(e)
if err != nil ... | func CreateEntries(s beam.Scope, treeID int64, records beam.PCollection) beam.PCollection {
return beam.ParDo(s.Scope("mapentries"), &mapEntryFn{treeID}, records)
} | func (sm *StateMachine) sendAppendEntries(ctx context.Context) error {
if sm.role != konsen.Role_LEADER {
return nil
}
currentTerm, err := sm.storage.GetCurrentTerm()
if err != nil {
return fmt.Errorf("failed to get current term: %v", err)
}
for server := range sm.cluster.Servers {
if server != sm.cluster... | func (pu *ProjectUpdate) AddRuns(r ...*Run) *ProjectUpdate {
ids := make([]string, len(r))
for i := range r {
ids[i] = r[i].ID
}
return pu.AddRunIDs(ids...)
} | func (r *Raft) handleAppendEntries(m pb.Message) {
msg := new(AppendEntriesRequest)
msg.FromPb(m)
r.followerHandleMsgAppend(msg)
} | func AddMultiSeriesWays(mlist []*SeriesWays) (err error) {
o := orm.NewOrm()
_, err = o.InsertMulti(20, mlist)
return
} | func (c *inMemoryCache) WriteEntries(dbName, path string, entries []*osv.Entry) error {
c.mu.Lock()
defer c.mu.Unlock()
cached := c.lookupDBLocked(dbName)
cached.entry[path] = entries
return c.underlying.WriteEntries(dbName, path, entries)
} | func (rf *Raft) BroadcastAppendEntries() {
rf.mu.Lock()
defer rf.mu.Unlock()
if rf.raftState == LEADER {
for i := 0; i < len(rf.peers); i++ {
if i != rf.me {
baseIndex := rf.Logs[0].Index
nextIndex := rf.nextIndex[i]
if nextIndex <= baseIndex {
args := InstallSnapshotArgs{Term: rf.CurrentTerm, ... | func (c *OVClient) AddMultipleRackServers(rackServer ServerHardware) error {
log.Infof("Adding multiple rack servers %s.", rackServer.Hostname)
var (
uri = "/rest/server-hardware/discovery"
t *Task
)
// refresh login
c.RefreshLogin()
c.SetAuthHeaderOptions(c.GetAuthHeaderMap())
log.Debugf("REST : %s \n %+... | func SendAppendEntries(
target *labrpc.ClientEnd,
args AppendEntriesArgs,
reply *AppendEntriesReply,
cm *CongestionMonitor,
) bool {
if cm.Congested() {
return false
}
ok := false
doneCh := cm.Begin(50 * time.Millisecond)
go SendAppendEntriesAsync(
target, args, reply, &ok, cm, doneCh)
cm.WaitForResult(d... | func addToLog(n int, term int, s *[]LogEntry) {
for i := 0; i < n; i++ {
*s = append(*s, LogEntry{Term: term, Command: term})
}
} | func (db *DB) AddEntry(date string, text string) {
if _, ok := db.entries[date]; !ok {
db.entries[date] = []string{text}
return
}
db.entries[date] = append(db.entries[date], text)
} | func (bf *Filter) AddMulti(key string, values [][]byte, client *redis.Client) error {
bitset := bf.bitset(values)
bloomisKey := prepareFilterKey(key)
multi := client.Multi()
_, err := multi.Exec(func() error {
for bit := range bitset {
multi.SetBit(bloomisKey, bit, 1)
}
return nil
})
return err
} | func (c *Client) WriteLogEntries(ctx context.Context, req *loggingpb.WriteLogEntriesRequest) (*loggingpb.WriteLogEntriesResponse, error) {
ctx = metadata.NewContext(ctx, c.metadata)
var resp *loggingpb.WriteLogEntriesResponse
err := gax.Invoke(ctx, func(ctx context.Context) error {
var err error
resp, err = c.cl... | func (c *Client) AddDictionaryEntries(ID string, e []DictionaryEntry) (*HTTPResponse, error) {
return c.doRequest("/entities/"+ID+"/", http.MethodPost, DefaultHeaders(contentTypeJSON), &DictionaryEntryList{Entries: e}, &EmptyResponse{})
} | func (client *SBClient) AddEntry(entry string) error {
roomName := client.config.Room
headers := make(map[string]string)
headers["Entry-Text"] = entry
response, err := client.call(http.MethodPost, "/gameplay/"+roomName, nil, headers)
if err != nil {
return fmt.Errorf("error during http request: %e", err)
}
swi... | func (node *Node) RpcAppendEntries(req *AppendEntriesReq, resp *AppendEntriesResp) error {
msg := &rpcMsg{
msgType: append_entries_req,
msg: req,
respCh: make(chan interface{}),
}
node.msgChan <- msg
reply := <-msg.respCh
resp = reply.(*AppendEntriesResp)
return nil
} | func AddEntry(db *sql.DB, jd string, je string) {
rows, err := db.Query(`SELECT * FROM journal_entries WHERE date = ?`, jd)
if err != nil {
log.Fatal(err)
}
defer rows.Close()
dateExists := false
for rows.Next() {
err := rows.Scan(&dbid, &dbdate, &dbentry)
if err != nil {
log.Fatal(err)
}
if jd == ... | func (a *Client) AddTagsMultiple(params *AddTagsMultipleParams, authInfo runtime.ClientAuthInfoWriter) (*AddTagsMultipleOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewAddTagsMultipleParams()
}
result, err := a.transport.Submit(&runtime.ClientOperation{
ID: ... | func (rf *Raft) SendAppendEntries(server int, args *AppendEntriesArgs, reply *AppendEntriesReply) bool {
ok := rf.peers[server].Call("Raft.AppendEntries", args, reply)
if ok {
//TODO
rf.mu.Lock()
defer rf.mu.Unlock()
//fmt.Printf("Appendentries reply %v\n", reply.Success)
//fmt.Printf("server %v log: %v\n",... | func (m *Manager) AddMultiJobs(jobs []*JOB.Job) {
defer m.lock.Unlock()
m.lock.Lock()
for _, job := range jobs {
m.Jobs[job.ID] = job
}
} | func (rf *Raft) AppendEntries(args AppendEntryArgs, reply *AppendEntryReply) {
rf.mu.Lock()
reply.Success = false
defer rf.mu.Unlock()
if args.Term < rf.currentTerm {
reply.Term = rf.currentTerm
reply.NextIndex = rf.logs[len(rf.logs)-1].Index + 1
return
}
var toFollower = (args.LeaderId != rf.me && args.... | func (s *WorkspaceService) AddEntities(ctx context.Context,
workspaceNameOrID *string, entityIds *string) (*[]map[string]interface{}, error) {
if entityIds == nil {
return nil, errors.New("entityIds cannot be nil")
}
endpoint := fmt.Sprintf("/workspaces/%v/entities", *workspaceNameOrID)
var entities struct {
... | func (ms *MemoryStorage) Append(entries []pb.Entry) error {
if len(entries) == 0 {
return nil
}
ms.Lock()
defer ms.Unlock()
first := ms.firstIndex()
last := entries[0].Index + uint64(len(entries)) - 1
// shortcut if there is no new entry.
if last < first {
return nil
}
// truncate compacted entries
if... | func (game *Game) AddEntry(entry string, issuer string) error {
if issuer != game.Turn {
return errors.New("invalid entry - not this player's turn")
}
if game.MaxLength > 0 && len(entry) > game.MaxLength {
return fmt.Errorf("invalid entry - entry is above max length (%v)", game.MaxLength)
}
game.Story = appen... | func (t *RuneTree) AddAll(keyFn KeyFunc, entries []*jmdict.Entry) {
for i, entry := range entries {
keys := keyFn(entry)
for _, key := range keys {
t.Add(key, entries[i])
}
}
} | func (c *MatrixClient) GetEntries() ([]Entry, error) {
requestBody := "uniqueToken=" + c.nextUniqueToken + "&menuform_SUBMIT=1&autoScroll=&javax.faces.ViewState=" + c.nextViewState + "&activateMenuItem=tim_searchWebBookingMss&menuform%3AmainMenu_mss_root_menuid=" + c.bookingID + "&data-matrix-treepath=mss_root.tim_sea... | func (c *Client) UpdateEntityEntries(eidOrName string, entries []EntityEntryObject) (result ApiResponse, err error) {
var bytes []byte
if bytes, err = c.httpPut(fmt.Sprintf("entities/%s/entries", eidOrName), nil, entries); err == nil {
if err = json.Unmarshal(bytes, &result); err == nil {
return result, nil
}
... | func (h *Handler) DeleteEntries(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
// Make sure session still valid
h.auth.MustAuthenticateUser(r)
// Decode request
var ids []int
err := json.NewDecoder(r.Body).Decode(&ids)
checkError(err)
// Start transaction
// Make sure to rollback if panic eve... | func (p *EpAll) ActionEntries(entries ...upstream.Entry) ([]upstream.Entry, error) {
if len(entries) == 0 {
return nil, fs.ErrorObjectNotFound
}
entries = filterROEntries(entries)
if len(entries) == 0 {
return nil, fs.ErrorPermissionDenied
}
return entries, nil
} | func addItemsToFeed(feed *atom.Feed, events []atomdata.TimestampedEvent, linkhostport, proto string) {
for _, event := range events {
encodedPayload := base64.StdEncoding.EncodeToString(event.Payload.([]byte))
content := &atom.Text{
Type: event.TypeCode,
Body: encodedPayload,
}
entry := &atom.Entry{
... | func (rf *Raft) addToLog(entries []EntrieArgs, j int) {
for i:= 0 ; i < len(entries) ;i++ {
if j > rf.lastLogIndex() {
rf.Log = append(rf.Log,entries[i:]...)
break
} else if (rf.Log[j].Term != entries[i].Term) {
rf.Log = append(rf.Log[:j],entries[i:]...)
break
}
j = j + 1
}
} | func (rf *Raft) applyEntries() {
rf.mu.Lock()
defer rf.mu.Unlock()
if rf.CommitIndex <= rf.LastApplied {
// no unapply logEntries, skipped
return
}
logs := rf.logEntries[rf.LastApplied:rf.CommitIndex]
if len(logs) == 0 {
return
}
DPrintf("%s applyEntries: %+v", rf, logs)
for _, entry := range logs {
... | func (tracker *FreshBooks) SaveEntries(entries []Entry) []Entry {
currEntries := tracker.LoadEntries()
res := []Entry{}
for _, entry := range entries {
if entry.ExternalID == 0 {
res = append(res, tracker.CreateEntry(entry))
} else {
for _, curr := range currEntries {
if curr.ExternalID == entry.Exter... | func (db *MemDb) AddEntry(e Entry) Entry {
log.Println("AddEntry", e)
return db.AddGroupEntry("", e)
} | func createUpdateEntries(numEntries int, bundles map[spiffeid.TrustDomain]*spiffebundle.Bundle) *UpdateEntries {
updateEntries := &UpdateEntries{
Bundles: bundles,
RegistrationEntries: make(map[string]*common.RegistrationEntry, numEntries),
}
for i := 0; i < numEntries; i++ {
entryID := fmt.Sprint... | func (s *Store) AppendEntry(arg *Action, unusedRetVal *uint64) error {
StoreChannel <- *arg
return nil
} | func (l *mySQLLog) Entries(s beam.Scope, start, end int64) beam.PCollection {
return databaseio.Query(s, "mysql", l.dbString, fmt.Sprintf("SELECT id AS Seq, data AS Data FROM leaves WHERE id >= %d AND id < %d", start, end), reflect.TypeOf(pipeline.InputLogLeaf{}))
} | func (r *NodeRegistry) addEntry(entry *NodeRegistryEntry) error {
for _, name := range entry.nodeKindNames {
if _, exists := r.nodeIndex[name]; exists {
return fmt.Errorf("node kind %q already registered in Node Registry", name)
}
r.nodeIndex[name] = entry
}
return nil
} | [
"0.6170258",
"0.6089603",
"0.60135806",
"0.57984656",
"0.57861674",
"0.57674867",
"0.5760889",
"0.5745432",
"0.5716209",
"0.57028496",
"0.5702722",
"0.5677012",
"0.5675292",
"0.55914074",
"0.55886495",
"0.55641985",
"0.5549496",
"0.5527229",
"0.5521827",
"0.5516046",
"0.54840... |
Delete deletes one or more existing boards. | func (s *BoardService) Delete(boardIDs []string) (*http.Response, error) {
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(boardIDs, ","))).Receive(nil, apiError)
return resp, relevantError(err, apiError)
} | func (o *Board) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if o == nil {
return 0, errors.New("model: no Board provided for delete")
}
if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), ... | func (r *board) Delete(boardId uint16, timecode uint32) (err error) {
f, err := r.Find(boardId, timecode)
if err != nil {
return
}
f.SetDeleted(true)
return r.Update(boardId, f)
} | func DeleteBoard(id int) error {
const q = `DELETE FROM billboards WHERE id = $1`
_, err := db.Exec(q, id)
return err
} | func DeleteShareBoard(id int) (err error) {
o := orm.NewOrm()
v := ShareBoard{Id: id}
// ascertain id exists in the database
if err = o.Read(&v); err == nil {
var num int64
if num, err = o.Delete(&ShareBoard{Id: id}); err == nil {
fmt.Println("Number of records deleted in database:", num)
}
}
return
} | func (o BoardSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if len(o) == 0 {
return 0, nil
}
if len(boardBeforeDeleteHooks) != 0 {
for _, obj := range o {
if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
}
}
var args []interface{}
for ... | func ListDeleteByBoardID(ctx context.Context, boardID int) (string, error) {
db := config.ConnectGorm()
sqlDB, _ := db.DB()
defer sqlDB.Close()
if err := db.Exec("DELETE l.* FROM list as l INNER JOIN board as b on b.id = l.board_id WHERE b.id = ?", boardID).Error; err != nil {
fmt.Println(err)
return "Failed",... | func DeleteOnboarding(id int) (err error) {
m := Onboarding{}
dbu := database.DB.New()
dbu.Where("id = ?", id).Delete(&m)
return
} | func (j *JDB) Delete(w http.ResponseWriter, r *http.Request) {
path := mux.Vars(r)["host"]
col := mux.Vars(r)["col"]
id := mux.Vars(r)["slug"]
if err := j.db.Delete(path+"/"+col, id); err != nil {
fmt.Println("Error", err)
}
return
} | func (c *Controller) Delete(input []string) error {
cmd := &Command{Name: input[0], QueueName: input[1]}
err := c.repo.DeleteQueue(cmd.QueueName)
if err != nil {
log.Printf("Can't delete queue %s: %s", cmd.QueueName, err.Error())
return errors.New("SERVER_ERROR " + err.Error())
}
fmt.Fprint(c.rw.Writer, "END\r... | func (g *Boards) Remove(w http.ResponseWriter, r *http.Request) {
// Get board public key.
bpk, e := misc.GetPubKey(r.FormValue("board"))
if e != nil {
send(w, e.Error(), http.StatusBadRequest)
return
}
if e := g.remove(bpk); e != nil {
send(w, e.Error(), http.StatusBadRequest)
} else {
send(w, true, http... | func (q boardQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if q.Query == nil {
return 0, errors.New("model: no boardQuery provided for delete all")
}
queries.SetDelete(q.Query)
result, err := q.Query.ExecContext(ctx, exec)
if err != nil {
return 0, errors.Wrap(err, "model:... | func (s *ConsumerCRUD) Delete(arg ...crud.Arg) (crud.Arg, error) {
event := eventFromArg(arg[0])
Consumer := consumerFromStuct(event)
print.DeletePrintln("deleting consumer", Consumer.Identifier())
return Consumer, nil
} | func Delete(opt Opt, ids ...int) {
db := openDB(opt)
for _, id := range ids {
err := db.Delete(id)
cli.Check(err)
}
} | func (lobby *Lobby) Delete(node sqalx.Node) error {
tx, err := node.Beginx()
if err != nil {
return err
}
defer tx.Rollback()
_, err = sdb.Delete("lobby").
Where(sq.Eq{"id": lobby.ID}).RunWith(tx).Exec()
if err != nil {
return fmt.Errorf("RemoveLobby: %s", err)
}
tx.Delete(getCacheKey("lobby", lobby.ID))... | func (stack *Stack) Delete(c *Config) (int, error) {
req, err := http.NewRequest(http.MethodDelete, c.CheEndpointURI+"/api/stack/"+stack.ID, nil)
req.Header.Set("Accept", "application/json")
if err != nil {
return -1, fmt.Errorf("%s", err)
}
cheClient := http.Client{}
resp, err := cheClient.Do(req)
log.Debu... | func (client BaseClient) DeleteBoardMethod(ctx context.Context, ID int32) (result autorest.Response, err error) {
req, err := client.DeleteBoardMethodPreparer(ctx, ID)
if err != nil {
err = autorest.NewErrorWithError(err, ".BaseClient", "DeleteBoardMethod", nil , "Failure preparing request")
... | func (s *BoardService) DeleteMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, "... | func (g *Game) Delete(w http.ResponseWriter, r *http.Request) {
//TODO
_, err := g.repo.Delete(r.Context(), int64(1))
if err != nil {
responseWithError(w, http.StatusInternalServerError, "Error try delete by id")
}
responseWithJSON(w, http.StatusMovedPermanently, map[string]string{"message": "Delete successful... | func DeleteBeans(ctx context.Context, beans ...any) (err error) {
e := GetEngine(ctx)
for i := range beans {
if _, err = e.Delete(beans[i]); err != nil {
return err
}
}
return nil
} | func deleteBeans(e Engine, beans ...interface{}) (err error) {
for bean := range beans {
if _, err = e.Delete(bean); err != nil {
return err
}
}
return nil
} | func (o *CompositesRoom) Delete(exec boil.Executor) (int64, error) {
if o == nil {
return 0, errors.New("models: no CompositesRoom provided for delete")
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), compositesRoomPrimaryKeyMapping)
sql := "DELETE FROM \"composites_rooms\" WHERE \"comp... | func (c *Cards) Delete(ctx context.Context, w http.ResponseWriter, r *http.Request) error {
id := chi.URLParam(r, "id")
if err := card.Delete(ctx, c.db, id); err != nil {
switch err {
case card.ErrInvalidID:
return web.NewRequestError(err, http.StatusBadRequest)
default:
return errors.Wrapf(err, "deletin... | func (p *Post) Delete() error {
_, err := pinboardMethod("delete", p)
return err
} | func (c *TeamController) Delete(ctx *app.DeleteTeamContext) error {
// TeamController_Delete: start_implement
if err := models.Delete(constants.DB_TEAM, ctx); err != nil {
return goa.ErrInternal(err, "endpoint", "delete")
}
return ctx.NoContent()
// TeamController_Delete: end_implement
} | func (mdb *MongoDatabase) DeleteCard(boardID, columnID, cardID string) error {
ctx := context.TODO()
boardIDHex, _ := primitive.ObjectIDFromHex(boardID)
columnIDHex, _ := primitive.ObjectIDFromHex(columnID)
cardIDHex, _ := primitive.ObjectIDFromHex(cardID)
filterBson := bson.M{"_id": boardIDHex, "columns._id": c... | func (p *Platform) Delete() {
for _, s := range p.outSteps {
p.M.Delete(s)
}
for _, s := range p.inSteps {
p.M.Delete(s)
}
p.M.Delete(p)
} | func (db *Database) MessageQueueDelete(rowIds []int) (int, error) {
//create table if needed
err := db.MessageQueueCreateTable()
if err != nil {
return 0, err
}
//build and execute query
stmtStr := "DELETE FROM message_queue WHERE rowid IN (?" + strings.Repeat(",?", len(rowIds)-1) + ")"
stmt, err := db.Db.Pr... | func deleteController(ctx echo.Context) error {
clowdee := ctx.Get("clowdee").(*model.Clowdee)
// bind deletion list from the request body
files := make([]*fileToDelete, 0)
if err := ctx.Bind(&files); err != nil {
logger.File().Infof("Error binding client's delete list, %s", err)
return err
}
// make file n... | func (p *Projects) Delete(guid string) error {
url := fmt.Sprintf("%s/api/projects/%s", p.sockAddr, guid)
req, err := http.NewRequest(http.MethodDelete, url, strings.NewReader(""))
if err != nil {
return err
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
... | func (p *Project) Delete() error {
db, err := sqlx.Open("postgres", connStr)
if err != nil {
return err
}
defer db.Close()
_, err = db.Queryx("delete from autochrone.sprints where project_id = $1", p.ID)
if err != nil {
return err
}
_, err = db.Queryx("delete from autochrone.projects where id = $1", p.ID)
... | func (uc *Workout) Delete(id int) error {
err := uc.wRepo.Delete(id)
if err != nil {
return err
}
return nil
} | func (r *ComboRoute) Delete(handlers ...Handler) *ComboRoute {
return r.route(r.router.Delete, http.MethodDelete, handlers...)
} | func (o *WorksFor) Delete(exec boil.Executor) error {
if o == nil {
return errors.New("models: no WorksFor provided for delete")
}
if err := o.doBeforeDeleteHooks(exec); err != nil {
return err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), worksForPrimaryKeyMapping)
sql := "DELET... | func (c *Consumer) Delete() error {
consumers := store.Use("Consumers")
return consumers.Delete(c.id)
} | func (srv *Projects) Delete(c context.Context, req *projects.DeleteRequest) (*emptypb.Empty, error) {
srv.cfg.Delete(req.GetId())
return &emptypb.Empty{}, nil
} | func (t *Team) Delete(db DB) error {
const sqlstr = `DELETE FROM team WHERE id = $1`
_, err := db.Exec(sqlstr, t.ID)
return err
} | func DeleteClues(id int) (err error) {
o := orm.NewOrm()
v := Clues{Id: id}
// ascertain id exists in the database
if err = o.Read(&v); err == nil {
var num int64
if num, err = o.Delete(&Clues{Id: id}); err == nil {
fmt.Println("Number of records deleted in database:", num)
}
}
return
} | func Delete(r *http.Request) error {
// Getting the JSON sent from Frontend
// And then decoding the JSON to Blog Struct
var b Blogs
json.NewDecoder(r.Body).Decode(&b)
// Show the result
fmt.Printf("%v \n", b)
// Removing the Blog Post from RethingDB
// TODO Add Validation
resp, err := rethink.DB("api").Table... | func (m *sqlRepository) Delete(ctx context.Context) error {
return m.DB(ctx).Delete(&model.Post{}).Error
} | func (ctrl OrganizationController) Delete(c *gin.Context) {
organization := c.MustGet(cOrganization).(common.Organization)
user := c.MustGet(cUser).(common.User)
var projectIDs []bson.ObjectId
orgIter := db.Projects().Find(bson.M{"organization_id": organization.ID}).Select(bson.M{"_id": 1}).Iter()
var project com... | func (c Pokemon) Delete(w http.ResponseWriter, r *http.Request) {
log.Println("Request Create")
var param ParamsOne
if err := rest.DecodeURL(r, ¶m); err != nil {
rest.Handler(w, err)
return
}
rows, err := c.S.Delete(param.ID)
if err != nil {
rest.Handler(w, err)
return
}
if rows == 0 {
rest.JSON(w... | func (p Database) Delete(id, rev string) error {
headers := map[string][]string{
"If-Match": []string{rev},
}
u := fmt.Sprintf("%s/%s", p.DBURL(), id)
ir := Response{}
if err := interact("DELETE", u, headers, nil, &ir); err != nil {
return err
}
if !ir.Ok {
return fmt.Errorf("%s: %s", ir.Error, ir.Reason)
... | func (t *SimpleChaincode) Delete(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
name := args[0]
err := stub.DelState(name) //remove the key from chaincode state
if err != nil {
return nil, errors.New... | func (s *Server) DeleteCards(ctx context.Context, in *pb.DeleteRequest) (*pb.CardList, error) {
log.Printf("DELETE: %v", in)
if in.Hash != "" {
s.cards = s.remove(in.Hash)
} else {
s.cards = s.removePrefix(in.HashPrefix)
}
s.SaveCardList(ctx)
return s.cards, nil
} | func (vk *VK) BoardDeleteTopic(params Params) (response int, err error) {
err = vk.RequestUnmarshal("board.deleteTopic", &response, params)
return
} | func (kc *Consumers) Delete(id string) error {
if utilities.IsValidUUID(id) {
path := fmt.Sprintf("%s/%s", ConsumersURI, id)
if _, err := kc.kong.Session.BodyAsJSON(nil).Delete(path, kc.consumer, kc.fail); err != nil {
return err
}
return nil
}
return errors.New("consumer cannot be null nor empty")
} | func DeleteCowboy(w http.ResponseWriter, r *http.Request) {
params := mux.Vars(r)
for index, item := range cowboys {
if item.ID == params["id"] {
cowboys = append(cowboys[:index], cowboys[index+1:]...)
break
}
}
json.NewEncoder(w).Encode(cowboys)
} | func (c Client) Delete(ctx context.Context, request *DeleteRequest) error {
if request.ProviderID == "" {
klog.Warningf("can not delete machine %s, providerID not set", request.MachineID)
return fmt.Errorf("machine %s has not been created", request.MachineID)
}
// Release MAAS machine
releaseArgs := gomaasapi... | func (r *Router) Delete(c *gin.Context) {
defer r.release(c)
id := c.Param("id")
if _, err := r.uuid(id); err != nil {
r.err(c, err)
return
}
exists, err := r.m.Exists(r.m.Path(id, "version"))
if err != nil {
r.err(c, err)
return
} else if !exists {
r.err(c, ErrProjectNotFound)
return
}
keys, err :... | func (s *server) Delete(ctx context.Context, body *pb.NameHolder) (*pb.DeletionResponse, error) {
appName := body.GetName()
filter := types.M{
mongo.NameKey: appName,
mongo.InstanceTypeKey: mongo.AppInstance,
}
node, _ := redis.FetchAppNode(appName)
go redis.DecrementServiceLoad(ServiceName, node)
go... | func (r *TopGamesMongo) Delete(id int) error {
_, err := r.db.DeleteOne(
r.ctx,
bson.D{
primitive.E{
Key: "_id",
Value: id,
},
})
return errors.Wrap(err, "Delete failed")
} | func (b *Building) Delete(w http.ResponseWriter, r *http.Request) {
svc := services.NewBuildingService()
s, _ := strconv.ParseInt(strings.TrimSpace(chi.URLParam(r, "id")), 10, 64)
data := services.NewBuildingDelete(s)
//chk
if data.ID == 0 {
//400
b.ReplyErrContent(w, r, http.StatusBadRequest, http.Stat... | func (k *ConsumersCollection) Delete(usernameOrID string) error {
consumer, err := k.Get(usernameOrID)
if err != nil {
return errors.Wrap(err, "looking up consumer")
}
txn := k.db.Txn(true)
defer txn.Abort()
err = txn.Delete(consumerTableName, consumer)
if err != nil {
return errors.Wrap(err, "delete fail... | func (client BaseClient) DeleteBoardMethodSender(req *http.Request) (*http.Response, error) {
return autorest.SendWithSender(client, req,
autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...))
} | func Delete(db gorp.SqlExecutor, ID int64) error {
m := WorkerModel(sdk.Model{ID: ID})
count, err := db.Delete(&m)
if err != nil {
return sdk.WithStack(err)
}
if count == 0 {
return sdk.WithStack(sdk.ErrNoWorkerModel)
}
return nil
} | func (o *Host) Delete(db *gorm.DB) error {
return db.Delete(o).Error
} | func (c DGamesController) Delete(id string) revel.Result {
if !c.GetCurrentUser() {
return c.Redirect("/spyc_admin/sessions/new")
}
var game models.WebGame
if WebGame, ok := app.Mapper.GetModel(&game); ok {
if err := WebGame.Find(id).Exec(&game); err != nil {
return c.ErrorResponse(err, err.Error(), 400)
... | func (s *csServer) Delete(ctx context.Context, c *cs.Card) (*cs.Empty, error) {
tx, err := s.db.Begin()
if err != nil {
log.Println(err)
return nil, grpc.Errorf(codes.Unknown, err.Error())
}
rows, err := tx.DeleteCard(c)
if err != nil {
log.Println(err)
tx.Rollback()
return nil, grpc.Errorf(codes.Unkno... | func (t *TeamModel) Delete(teamID string, orms ...orm.Ormer) (uint32, error) {
var o orm.Ormer
if len(orms) != 1 {
o = orm.NewOrm()
} else {
o = orms[0]
}
_, err := o.QueryTable(t.TableName()).Filter("id", teamID).Delete()
return sqlstatus.ParseErrorCode(err)
} | func (c *FakeRocketmqs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(rocketmqsResource, c.ns, name), &v1alpha1.Rocketmq{})
return err
} | func (d *OvsdbDriver) Delete() error {
if d.ovs != nil {
log.Infof("Deleting OVS bridge: %s", d.bridgeName)
for i := 0; i < 3; i++ {
err := d.createDeleteBridge(d.bridgeName, "", operDeleteBridge)
if err != nil {
log.Errorf("Error deleting the bridge %s. Err: %v", d.bridgeName, err)
time.Sleep(300 * ... | func (s *GroupIssueBoardsService) DeleteGroupIssueBoardList(gid interface{}, board, list int, options ...RequestOptionFunc) (*Response, error) {
group, err := parseID(gid)
if err != nil {
return nil, err
}
u := fmt.Sprintf("groups/%s/boards/%d/lists/%d",
PathEscape(group),
board,
list,
)
req, err := s.cl... | func (s *Shift) Delete(db *gorm.DB) error {
tx := db.Delete(s)
err := tx.Error
if err != nil {
return err
}
if tx.RowsAffected == 0 {
return errors.New("shift not found")
}
return nil
} | func (*server) Delete(ctx context.Context, req *model.DeleteReq) (*model.DeleteResp, error) {
ID := req.GetId()
blogID, err := primitive.ObjectIDFromHex(ID)
log.Printf("Req => %v\n", req)
if err != nil {
errMsg := status.Errorf(codes.InvalidArgument, "Failed read ID")
return nil, errMsg
}
data := &dataItem... | func (o *Cvtermprop) Delete(exec boil.Executor) error {
if o == nil {
return errors.New("chado: no Cvtermprop provided for delete")
}
if err := o.doBeforeDeleteHooks(exec); err != nil {
return err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cvtermpropPrimaryKeyMapping)
sql := "... | func (c *mongoDBs) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
return c.client.Delete().
Namespace(c.ns).
Resource("mongodbs").
Name(name).
Body(&opts).
Do(ctx).
Error()
} | func (c *Nomad) DeleteConfigs() error {
for _, host := range append(c.Cfg.Clients, c.Cfg.Servers...) {
_, err := ssh.Ssh(host, c.Cfg, "bash -c \"rm -rf /etc/nomad.d\"")
if err != nil {
return err
}
}
return nil
} | func DeletePost(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
db := driver.DBConn()
postRepo := repositories.NewPostRepo(db)
id := chi.URLParam(r, "id")
number, _ := strconv.ParseInt(id, 10, 0)
postRepo.DeletePost(number)
respondwithJSON(w, http.StatusOK, map[strin... | func (tm *Team) delete() error {
var err error
if err = db.open(); err != nil {
return err
}
defer db.close()
teamPath := []string{"teams"}
return db.bolt.DeleteBucket(teamPath, tm.UUID)
} | func (qb *QueueBlock) Delete() error {
return DBConn.Delete(qb).Error
} | func Delete(app string) error {
// set up helm client
client, _, err := getKubeClient(kubeContext)
if err != nil {
return fmt.Errorf("Could not get a kube client: %s", err)
}
// delete Draft storage for app
store := configmap.NewConfigMaps(client.CoreV1().ConfigMaps("default"))
if _, err := store.DeleteBuilds... | func (s *Service) Delete(ctx context.Context) (_ *ctrl.Result, err error) {
serverList, err := s.listMatchingMachines(ctx)
if err != nil {
if checkRateLimitExceeded(err) {
s.scope.Recorder.Eventf(s.scope.BareMetalMachine, corev1.EventTypeWarning, "HrobotRateLimitExceeded", "Hrobot rate limit exceeded. Wait for ... | func (c *PanoBgp) Delete(tmpl, ts, vr string) error {
var err error
if tmpl == "" && ts == "" {
return fmt.Errorf("tmpl or ts must be specified")
} else if vr == "" {
return fmt.Errorf("vr must be specified")
}
c.con.LogAction("(delete) bgp config for %q", vr)
// Remove the ob... | func (pi *PushInfo) Delete(db XODB) error {
var err error
// if doesn't exist, bail
if !pi._exists {
return nil
}
// if deleted, bail
if pi._deleted {
return nil
}
// sql query
const sqlstr = `DELETE FROM devdb.push_info WHERE push_id = ?`
// run query
XOLog(sqlstr, pi.PushID)
_, err = db.Exec(sqlst... | func (flavor *Flavor) Delete() error {
d, err := db.Connect(nil)
if err != nil {
return err
}
sql := "DELETE FROM flavors WHERE flavor_id = $1"
_, err = d.Exec(sql, flavor.ID)
return err
} | func (c *Client) Delete(ctx context.Context, apiPath string) ([]byte, int, string, error) {
return c.sendRequest(ctx, apiPath, http.MethodDelete, nil)
} | func (gid GoogleID) Delete() error {
// teams require special attention since they might be linked to .rocks communities
var teamID TeamID
rows, err := db.Query("SELECT teamID FROM team WHERE owner = ?", gid)
if err != nil {
Log.Notice(err)
return err
}
defer rows.Close()
for rows.Next() {
rows.Scan(&teamI... | func (ms *MongoStore) Delete(id bson.ObjectId, coll string) error {
c := ms.ses.DB("game").C(coll)
if err := c.RemoveId(id); err != nil {
return err
}
return nil
} | func (d *passwordsService) Delete(ctx context.Context, deleteReq *DeleteDatabaseBranchPasswordRequest) error {
path := passwordBranchAPIPath(deleteReq.Organization, deleteReq.Database, deleteReq.Branch, deleteReq.PasswordId)
req, err := d.client.newRequest(http.MethodDelete, path, nil)
if err != nil {
return error... | func (mk *Matkul) Delete(db *sql.DB) error {
if mk.ID == "" {
return fmt.Errorf("id tidak bolehh kosong")
}
query := "DELETE FROM matkul where id = $1"
_, err := db.Exec(query, &mk.ID)
return err
} | func Delete(args ...string) *RunBuilder {
return withDefaults("delete", args)
} | func (s *service) Delete(c echo.Context) error {
id, _ := strconv.ParseInt(c.Param("id"), 10, 64)
if err := model.Delete(id); err != nil {
return c.JSON(http.StatusBadRequest, utils.MessageJSON{
Message: "Error removing fruit",
Value: err.Error(),
})
}
return c.JSON(http.StatusOK, utils.MessageJSON{
... | func (t *SimpleChaincode) Delete(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
record := args[0]
err := stub.DelState(record) //remove the key from chaincode state
if err != nil {
return nil, errors... | func (m Memory) Delete(id uint) error {
delete(m.IPSWs, id)
return nil
} | func (g Glo) DeleteBoardCard(boardID string, cardID string) {
resp := g.callAPI(
"DELETE",
g.pathBoards+"/"+boardID+g.pathCard+"/"+cardID,
nil,
nil,
)
if !resp.Ok {
log.Fatal("Error at delete card")
}
} | func (p *provider) Delete(ctx context.Context, name string, options *models.DeleteOptions) error {
log.WithFields(log.Fields{
"name": name,
}).Info("deleting the stack")
p.RLock()
defer p.RUnlock()
if _, found := p.stacks[name]; !found {
return models.ErrStackNotFound
}
delete(p.stacks, name)
return nil
... | func (c *AppCollection) Delete(ri Resource) error {
r := ri.(*AppResource)
components, err := r.Components().List()
if err != nil {
return err
}
for _, component := range components.Items {
if err := component.Delete(); err != nil {
return err
}
}
// TODO
// Ideally we would delete namespace first, be... | func (client *Client) Delete(ctx context.Context) error {
logger := lagerctx.FromContext(ctx)
sshClient, _, err := client.dial(ctx, 0)
if err != nil {
logger.Error("failed-to-dial", err)
return err
}
defer sshClient.Close()
return client.run(ctx, sshClient, "delete-worker", os.Stdout)
} | func (c *Combo) Delete(h ...interface{}) *Combo {
c.r.Delete(c.pattern, append(c.h, h...)...)
return c
} | func (o *CMFGame) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if o == nil {
return 0, errors.New("models: no CMFGame provided for delete")
}
if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(... | func (l Leftovers) Delete(filter string) error {
var deletables []Deletable
deletables, err := l.resource.List(filter)
if err != nil {
l.logger.Println(color.YellowString(err.Error()))
}
for _, d := range deletables {
l.logger.Println(fmt.Sprintf("[%s: %s] Deleting...", d.Type(), d.Name()))
err := d.Delet... | func (client BaseClient) DeleteBoardMethodResponder(resp *http.Response) (result autorest.Response, err error) {
err = autorest.Respond(
resp,
client.ByInspecting(),
azure.WithErrorUnlessStatusCode(http.StatusOK,http.StatusNoContent,http.StatusBadRequest,http.StatusUnauth... | func (c *cornerstone) DeleteBathes(model interface{}, condition map[string]interface{}) error {
return conn.GetDB().Where(condition).Delete(model).Error
} | func ApiWebsitesDelete(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
if !lib.IsLoggedIn(r) {
SendJsonMessage(w, http.StatusUnauthorized, false, "Unauthorized.")
return
}
// Get data from Request
value := ps.ByName("url")
// Simple Validation
if value == "" {
SendJsonMessage(w, http.Statu... | func (t *SimpleChaincode) Delete(stub shim.ChaincodeStubInterface, args []string) ([]byte, error) {
if len(args) != 1 {
return nil, errors.New("Incorrect number of arguments. Expecting 1")
}
name := args[0]
err := stub.DelState(name) //remove the key from chaincode state
if err != nil {
return nil, errors.New... | func (o *Blogger) Delete(exec boil.Executor) (int64, error) {
if o == nil {
return 0, errors.New("models: no Blogger provided for delete")
}
if err := o.doBeforeDeleteHooks(exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), bloggerPrimaryKeyMapping)
s... | func (s *Share) Delete(db *bolt.DB) error {
desc := "share deletion not supported"
return MakeError(ErrNotSupported, desc, nil)
} | func (o *UpepBlastDB) Delete(exec boil.Executor) error {
if o == nil {
return errors.New("models: no UpepBlastDB provided for delete")
}
if err := o.doBeforeDeleteHooks(exec); err != nil {
return err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), upepBlastDBPrimaryKeyMapping)
sql ... | func (o *Keyboard) Delete(db *gorm.DB) error {
return db.Delete(o).Error
} | func deleteConfigs(w http.ResponseWriter, id int, list *ConfigList) {
failedList := configList.Delete(list)
resp := jsonResponse{Id: id, ConfigList: failedList}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
fmt.Fprintln(w, resp)
} | [
"0.69330186",
"0.6714629",
"0.64691085",
"0.6098576",
"0.60093844",
"0.5973651",
"0.57029617",
"0.5677471",
"0.56718075",
"0.5669576",
"0.5659319",
"0.5562686",
"0.5502454",
"0.54067844",
"0.5329192",
"0.5317778",
"0.52946764",
"0.5265963",
"0.5223571",
"0.5216753",
"0.521196... |
DeleteEntry deletes one entry from one or more existing boards. | func (s *BoardService) DeleteEntry(BoardIDs []string, entryID string) (*http.Response, error) {
bodyJSON := &struct {
EntryID string `json:"entryId,omitempty"`
}{
EntryID: entryID,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).BodyJSON(body... | func (db *MemDb) DeleteEntry(key string) {
log.Println("DeleteEntry", key)
db.DeleteGroupEntry("", key)
} | func DeleteEntry(pKey int, db *gorm.DB) {
fmt.Println(pKey)
db.Delete(&Entry{}, pKey)
} | func EntryDelete(opts EntryOpts) error {
entries, err, stderr := getCronEntries(opts)
if err != nil {
return fmt.Errorf("unable to delete %s::%s: %s", cronEntryName, opts.Name, err)
}
if stderr != nil {
return fmt.Errorf("unable to add %s::%s: %s", cronEntryName, opts.Name, stderr)
}
var newEntries []string... | func (t *NetworkInstance_Fdb_MacTable) DeleteEntry(MacAddress string, Vlan uint16) {
key := NetworkInstance_Fdb_MacTable_Entry_Key{
MacAddress: MacAddress,
Vlan: Vlan,
}
delete(t.Entry, key)
} | func (runner *runner) DelEntry(entry string, set string) error {
if _, err := runner.exec.Command(IPSetCmd, "del", set, entry).CombinedOutput(); err != nil {
return fmt.Errorf("error deleting entry %s: from set: %s, error: %v", entry, set, err)
}
return nil
} | func (s *BoardService) DeleteMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, "... | func (c *Clipboard) DeleteEntry(id int) error {
entries := c.Entries
entries = append(entries[:id], entries[id+1:]...)
c.Entries = entries
return nil
} | func (c *Client) DeleteEntry(entryID string) error {
url := c.getReqURLWithID(resourceTiny, entryID)
req, err := http.NewRequest("DELETE", url, nil)
if err != nil {
return errors.Wrap(err, "failed to create request to fetch entry")
}
c.addAuthHeader(authWrite, req)
res, err := c.do(req)
if err != nil {
retur... | func DeleteEntry(w http.ResponseWriter, r *http.Request) {
db, err := sql.Open("mysql", connectionString)
defer db.Close()
if err != nil {
respondWithError(w, http.StatusInternalServerError, "Could not connect to the database")
return
}
id := r.URL.Query().Get("id")
var firstName sql.NullString
var lastName... | func (m MutableSecondaryIdx) DeleteEntry(ctx context.Context, key val.Tuple, value val.Tuple) error {
currKey := m.builder.SecondaryKeyFromRow(key, value)
err := m.mut.Delete(ctx, currKey)
if err != nil {
return nil
}
return nil
} | func (s *Service) DeleteEntry(ctx context.Context, in *pb.DeleteEntryRequest) (*empty.Empty, error) {
currentUser, err := s.getCurrentUser(ctx)
if err != nil {
return nil, status.Errorf(codes.PermissionDenied, "Authentication failed")
}
deletable, err := s.entryDeletable(int(in.GetEntryId()), int(currentUser.ID)... | func deleteEntry(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
id, err := strconv.Atoi(vars["id"])
if err != nil {
fmt.Fprintf(w, "Index is not an integer: %d", id)
}
newEntries, err := model.DeleteEntry(id)
if err != nil {
fmt.Fprintf(w, "Error deleting entry: %v", err)
retu... | func (a *Client) DeleteEntry(params *DeleteEntryParams) (*DeleteEntryNoContent, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteEntryParams()
}
result, err := a.transport.Submit(&runtime.ClientOperation{
ID: "deleteEntry",
Method: "DELETE"... | func (rc *Connector) DelEntry(key string) error {
if !rc.connected {
return errors.New("Redis Connector is disconnected (DelEntry)")
}
// Delete entry if it exists
_, err := rc.client.Del(key).Result()
if err != nil {
return err
}
return nil
} | func (s *Store) DeleteEntry(e *entry.Entry) error {
var err error
delete(s.entries, e.Name)
if s.entries[e.Name] != nil {
err = fmt.Errorf("Could not delete entry")
}
return err
} | func (ks KeyStore) DeleteEntry(alias string) {
delete(ks.m, ks.convertAlias(alias))
} | func DeleteEntry(db *sql.DB, jd string) {
statement, err := db.Prepare("DELETE FROM journal_entries WHERE date = ?")
if err != nil {
log.Fatal(err)
}
defer statement.Close()
statement.Exec(jd)
} | func DeleteEntryDB(db *Database, key string) error {
err := db.BoltDB.Update(func(tx *bolt.Tx) error {
err := tx.Bucket([]byte(db.Bucket)).Delete([]byte(key))
if err != nil {
return err
}
log.Printf("Bolt Bucket \"%s\", deleted \"%s\" key", db.Bucket, key)
return nil
})
if err != nil {
return err
}
... | func (h *Handler) DeleteEntries(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
// Make sure session still valid
h.auth.MustAuthenticateUser(r)
// Decode request
var ids []int
err := json.NewDecoder(r.Body).Decode(&ids)
checkError(err)
// Start transaction
// Make sure to rollback if panic eve... | func deleteEntry(db *BoltDB, bucket []byte, key string) error {
const funcName = "deleteEntry"
return db.DB.Update(func(tx *bolt.Tx) error {
pbkt := tx.Bucket(poolBkt)
if pbkt == nil {
desc := fmt.Sprintf("%s: bucket %s not found", funcName,
string(poolBkt))
return errs.DBError(errs.StorageNotFound, des... | func (r *redisStore) DeleteEntry(key string) (int, error) {
client, err := newClient()
// connection issue
if err != nil {
return -1, err
}
delCount := client.Del(key)
return int(delCount.Val()), nil
} | func (m *HAProxyMap) DeleteEntry(id string) error {
return m.deleteEntry(id)
} | func (h *HostsAPI) RemoveEntry(hostname string) error {
if _, exists := h.entries[hostname]; exists {
delete(h.entries, hostname)
} else {
return fmt.Errorf("failed to remove, hostname does not exist: %s", hostname)
}
return nil
} | func DeleteEntry(hostname string, ip string, ETCD string) {
fmt.Println("DeleteEntry called...")
var services = []*msg.Service{
{Host: ip, Key: hostname + "."},
{Host: hostname, Key: reverseIP(ip)},
}
client := etcd.NewClient([]string{ETCD})
//delete a service
serv := services[0]
path, _ := msg.PathWithWil... | func (c *restClient) DeleteEntry(ctx context.Context, req *datacatalogpb.DeleteEntryRequest, opts ...gax.CallOption) error {
baseUrl, err := url.Parse(c.endpoint)
if err != nil {
return err
}
baseUrl.Path += fmt.Sprintf("/v1/%v", req.GetName())
// Build HTTP headers from client and context metadata.
hds := []s... | func (c *Client) DeleteEntry(ctx context.Context, req *datacatalogpb.DeleteEntryRequest, opts ...gax.CallOption) error {
return c.internalClient.DeleteEntry(ctx, req, opts...)
} | func DBRemoveEntry(keys ...string) error {
_, err := dbClient.Del(keys...).Result()
if err != nil {
return err
}
return nil
} | func (s Storage) DeleteRebootsEntry(ctx context.Context, leaderKey string, index int64) error {
resp, err := s.Txn(ctx).
If(clientv3util.KeyExists(leaderKey)).
Then(clientv3.OpDelete(rebootsEntryKey(index))).
Commit()
if err != nil {
return err
}
if !resp.Succeeded {
return ErrNoLeader
}
return nil
} | func (e Entry) Delete() error {
if !database.Main.Opened {
return fmt.Errorf("db must be opened before deleting")
}
return database.Main.DB.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(Bucket))
if b == nil {
return fmt.Errorf("Could not find bucket : %s", Bucket)
}
return b.Delete([]byte(strco... | func DeleteEntry(storage core.StorageClient) gin.HandlerFunc {
return func(c *gin.Context) {
var (
err error
id string
)
id = c.Param("id")
if id == "" {
c.Status(http.StatusBadRequest)
return
}
err = storage.Delete(id)
if err != nil {
var storageError *core.StorageError
if errors.... | func (s *safeIpset) DelEntry(entry string, set string) error {
s.mu.Lock()
defer s.mu.Unlock()
return s.ipset.DelEntry(entry, set)
} | func (p *Entry) Delete(ctx context.Context, w http.ResponseWriter, r *http.Request, params map[string]string) error {
ctx, span := trace.StartSpan(ctx, "handlers.Entry.Delete")
defer span.End()
if err := entry.Delete(ctx, p.db, params["id"]); err != nil {
switch err {
case entry.ErrInvalidID:
return web.NewR... | func (t *System_Dns) DeleteHostEntry(Hostname string) {
key := Hostname
delete(t.HostEntry, key)
} | func deleteEntry(entry []UA_NodeMapEntry) {
UA_Node_deleteMembers((*[100000000]UA_Node)(unsafe.Pointer(&entry[0].node))[:])
_ = entry
} | func (ps *ParameterServer) deleteEntry(id string) {
ps.mu.Lock()
defer ps.mu.Unlock()
delete(ps.jobIndex, id)
} | func RemoveEntry(ID string) error {
d := Database
q := fmt.Sprintf("DELETE FROM entries WHERE entryID like '%s'", ID)
s, err := d.Prepare(q)
if err != nil {
return err
}
s.Exec()
return nil
} | func (db DB) DeleteReputationEntry(tx *sql.Tx, entry ReputationEntry) error {
exec := db.Exec
if tx != nil {
exec = tx.Exec
}
_, err := exec("DELETE FROM reputation WHERE ip = $1;", entry.IP)
return err
} | func (r *board) Delete(boardId uint16, timecode uint32) (err error) {
f, err := r.Find(boardId, timecode)
if err != nil {
return
}
f.SetDeleted(true)
return r.Update(boardId, f)
} | func (h *Hostsfile) RemoveEntry(host *Host) error {
defer h.File.Seek(0, 0)
// Read the contents of the hosts file.
f, err := ioutil.ReadAll(h.File)
if err != nil {
return errors.New("Unable to read hosts file.")
}
// Explode the contents into a slice by line. Create an empty slice for
// the modified file ... | func (e *EntryHandler) HandleDeleteEntry(w http.ResponseWriter, r *http.Request) {
vars := mux.Vars(r)
err := e.Service.DeleteEntry(vars["id"])
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
}
w.WriteHeader(http.StatusOK)
} | func (m *HAProxyMap) deleteEntry(id string) error {
cmd := fmt.Sprintf("del map %s #%s", m.name, id)
if _, err := m.client.Execute(cmd); err != nil {
return err
}
m.dirty = true
return nil
} | func (seMap *StringElementMap) DeleteEntry(key string) {
seMap.TraceableLock()
defer seMap.TraceableUnlock()
delete(seMap.elementMap, key)
} | func (db *mysqlDB) DeleteAddressBookEntry(id int64) error {
if id == 0 {
return errors.New("mysql: address book entry with unassigned ID passed into deleteAddressBookEntry")
}
_, err := execAffectingOneRow(db.delete, id)
return err
} | func (db *MemDb) DeleteGroupEntry(group, key string) {
log.Println("DeleteGroupEntry", group, key)
container := db.getContainer(group)
if ind, ok := container.kvsEntries[key]; ok {
container.entries[ind] = container.entries[len(container.entries)-1]
container.entries = container.entries[:len(container.entries)... | func RemoveEntry(name string) error {
return remove(getSSHConfigPath(), buildHostname(name))
} | func DeleteArpEntry(name string, arpEntry *netlink.Neigh, log logging.Logger, timeLog measure.StopWatchEntry) error {
log.Debugf("Deleting an ARP entry %v", name)
start := time.Now()
defer func() {
if timeLog != nil {
timeLog.LogTimeEntry(time.Since(start))
}
}()
return netlink.NeighDel(arpEntry)
} | func (mc *metadatacache) DeleteEntry(chunk apis.ChunkNum, previous apis.MetadataEntry) (apis.ServerName, error) {
metachunk, offset := ChunkToBlockAndOffset(chunk)
for {
data, version, owner, err := mc.leasing.Read(metachunk)
if err != nil {
return owner, err
}
found := getBitsetInData(data, ChunkToEntry... | func (index *Index) RemoveEntry(chartVersion *helm_repo.ChartVersion) {
if entries, ok := index.Entries[chartVersion.Name]; ok {
for i, cv := range entries {
if cv.Version == chartVersion.Version {
index.Entries[chartVersion.Name] = append(entries[:i],
entries[i+1:]...)
if len(index.Entries[chartVers... | func (c *Client) DeletePlanEntry(planID int, entryID string) error {
uri := "delete_plan_entry/" + strconv.Itoa(planID) + "/" + entryID
return c.sendRequest("POST", uri, nil, nil)
} | func (c *Client) DeleteTimeEntry(p DeleteTimeEntryParam) error {
err := required("delete time entry", map[field]string{
workspaceField: p.Workspace,
timeEntryIDField: p.TimeEntryID,
})
if err != nil {
return err
}
r, err := c.NewRequest(
"DELETE",
fmt.Sprintf(
"v1/workspaces/%s/time-entries/%s",
... | func (t *NetworkInstance_Afts) DeleteMacEntry(MacAddress string) {
key := MacAddress
delete(t.MacEntry, key)
} | func (t *NetworkInstance_Afts) DeleteLabelEntry(Label NetworkInstance_Afts_LabelEntry_Label_Union) {
key := Label
delete(t.LabelEntry, key)
} | func (c *client) DeleteTimeEntry(p DeleteTimeEntryParam) (err error) {
defer wrapError(&err, "delete time entry \"%s\"", p.TimeEntryID)
ids := map[field]string{
workspaceField: p.Workspace,
timeEntryIDField: p.TimeEntryID,
}
if err = required(ids); err != nil {
return err
}
if err = checkIDs(ids); err ... | func (set *IPSet) Delete(name string, entry string, options ...string) error {
return set.run(append([]string{"del", name, entry}, options...)...)
} | func (k *kwalletBinding) RemoveEntry(handle int32, folder string, key string, appid string) error {
call := k.dbus.Call("org.kde.KWallet.removeEntry", 0, handle, folder, key, appid)
if call.Err != nil {
return call.Err
}
return call.Err
} | func (r *PlaylistRepo) RemoveEntry(entryID uint) error {
r.logger.WithField(log.FldID, entryID).Debug("Deleting playlist entry")
query := "DELETE FROM PlaylistEntries WHERE id = ?"
res, err := r.db.Exec(query, entryID)
if err != nil {
return err
}
var num int64
if num, err = res.RowsAffected(); err == nil {
... | func (conn *Connection) DeleteTimeEntry(id string) (*DeleteTimeEntryResponse, error) {
method := "DELETE"
url := fmt.Sprintf("%stime_entries/%s.json", conn.Account.Url, id)
reader, _, err := request(conn.ApiToken, method, url, nil)
if err != nil {
return nil, err
}
// data, _ := ioutil.ReadAll(reader)
// fmt.P... | func (e *Entries) RemoveEntry(rm *Entry) error {
if len(rm.Username) == 0 {
return errors.New("must provide username to be removed")
}
// Look for the username, then remove it.
for i, entry := range *e {
if entry.Username == rm.Username {
s := *e
s = append(s[:i], s[i+1:]...)
*e = s
return nil
}
... | func (mp *metaPartition) DeleteDentry(req *DeleteDentryReq, p *Packet) (err error) {
dentry := &Dentry{
ParentId: req.ParentID,
Name: req.Name,
}
val, err := dentry.Marshal()
if err != nil {
p.PacketErrorWithBody(proto.OpErr, []byte(err.Error()))
return
}
r, err := mp.submit(opFSMDeleteDentry, val)
i... | func (c *EntryClient) Delete() *EntryDelete {
mutation := newEntryMutation(c.config, OpDelete)
return &EntryDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
} | func (g *GuestBook) RemoveEntry(id int) error {
// Acquaire our lock and make sure it will be released.
g.mutex.Lock()
defer g.mutex.Unlock()
// Check if we have a valid id.
if id < 0 || id >= len(g.guestBookData) ||
g.guestBookData[id] == nil {
return fmt.Errorf("invalid id")
}
// Set entry to nil. This i... | func (pos *Position) DeletePositionEntryMoves() {
Book.PositionEntries[pos.ZobristStr()] = BookPositionEntry{
MoveEntries : make(BookMoveEntries),
}
} | func (g *GoJSON) DelArrayEntry(val interface{}, Jsontype int) error {
var elem *GoJSON
elem, err := g.GetArrayEntry(val, Jsontype)
if err != nil {
return err
}
elem.Prev.Next = elem.Next
elem = nil
return nil
} | func (c *EntryClient) DeleteOne(e *Entry) *EntryDeleteOne {
return c.DeleteOneID(e.ID)
} | func (o *Board) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if o == nil {
return 0, errors.New("model: no Board provided for delete")
}
if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), ... | func (EmojiDelete) EntryType() EntryType { return EntryTypeEmojiDelete } | func deleteEntry(file string) {
delete(cacheFile, file)
} | func (k *KBEntry) Delete() error {
if util.IsEmpty(&k.Id) || len(k.Topic) == 0 {
return errors.New("KBEntry.Delete() invalid parameter(s)")
}
where_map := make(map[string]interface{})
where_map["topic"] = k.Topic
where_map["id"] = k.Id
return db.Cassandra.ExecuteWithRetry(db.Cassandra.Delete("knowledge_base",... | func DeleteBoard(id int) error {
const q = `DELETE FROM billboards WHERE id = $1`
_, err := db.Exec(q, id)
return err
} | func (IAssoc ImageVMAssociation) DeleteEntry() error {
log.Trace("wlavm/image_VM_association:DeleteEntry() Entering")
defer log.Trace("wlavm/image_VM_association:DeleteEntry() Leaving")
util.MapMtx.Lock()
_, ok := util.ImageVMAssociations[IAssoc.ImageUUID]
if ok {
log.Debug("wlavm/image_VM_association:DeleteEnt... | func (WebhookDelete) EntryType() EntryType { return EntryTypeWebhookDelete } | func (un *UnbondingNode) RemoveEntry(i int64) {
un.Entries = append(un.Entries[:i], un.Entries[i+1:]...)
} | func DeleteShareBoard(id int) (err error) {
o := orm.NewOrm()
v := ShareBoard{Id: id}
// ascertain id exists in the database
if err = o.Read(&v); err == nil {
var num int64
if num, err = o.Delete(&ShareBoard{Id: id}); err == nil {
fmt.Println("Number of records deleted in database:", num)
}
}
return
} | func (MessageDelete) EntryType() EntryType { return EntryTypeMessageDelete } | func (c *client) DeletePeerEntry(name string, peerSection string, transactionID string, version int64) error {
p, t, err := c.loadDataForChange(transactionID, version)
if err != nil {
return err
}
peerEntry, i := GetPeerEntryByName(name, peerSection, p)
if peerEntry == nil {
e := NewConfError(ErrObjectDoesNot... | func (*server) Delete(ctx context.Context, req *model.DeleteReq) (*model.DeleteResp, error) {
ID := req.GetId()
blogID, err := primitive.ObjectIDFromHex(ID)
log.Printf("Req => %v\n", req)
if err != nil {
errMsg := status.Errorf(codes.InvalidArgument, "Failed read ID")
return nil, errMsg
}
data := &dataItem... | func (ndns *NoopDNS) deleteEntries(name string, entries *Entries) error {
return nil
} | func (c *Client) DeleteDictionaryEntry(dictID, entryID string) (*HTTPResponse, error) {
return c.doRequest("/entities/"+dictID+"/"+entryID, http.MethodDelete, nil, nil, &EmptyResponse{})
} | func (c *MongoCollection) Delete(entryID string) (status error) {
c.MutexExec(func() {
var err error
b, idParseErr := GetObjectIDFromString(entryID)
if idParseErr != nil {
err = idParseErr
} else {
err = c.Database.Remove(c.Collection, b)
}
status = err
})
return status
} | func (ChannelDelete) EntryType() EntryType { return EntryTypeChannelDelete } | func (view *UtxoViewpoint) RemoveEntry(outpoint wire.OutPoint) {
delete(view.entries, outpoint)
} | func (s *BoardService) Delete(boardIDs []string) (*http.Response, error) {
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(boardIDs, ","))).Receive(nil, apiError)
return resp, relevantError(err, apiError)
} | func (rc *Connector) JSONDelEntry(key string, path string) error {
if !rc.connected {
return errors.New("Redis Connector is disconnected (JSONDelEntry)")
}
// Update existing entry or create new entry if it does not exist
_, err := rc.client.Del(key, path).Result()
if err != nil {
return err
}
return nil
} | func (o *Mainblog) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if o == nil {
return 0, errors.New("models: no Mainblog provided for delete")
}
if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueO... | func (d *TeibDescriptor) Delete(key string, entry *l3.TeibEntry, metadata interface{}) error {
return d.teibHandler.VppDelTeibEntry(context.Background(), entry)
} | func (e *entries) del(id string) error {
for idx, entry := range e.entries {
xact := entry.Get()
if xact.ID() == id {
if !xact.Finished() {
return fmt.Errorf("cannot remove %s - is running", xact)
}
nlen := len(e.entries) - 1
e.entries[idx] = e.entries[nlen]
e.entries = e.entries[:nlen]
break... | func removeEntry(pkgInfo []string) string {
// Check if pkg exists in tree, delete if not a dependency
_, ok := pkgIndex[pkgInfo[0]]
if ok {
if !isDependency(pkgInfo[0]) {
delete(pkgIndex, pkgInfo[0])
} else {
// Pkg was found, but it's a dep for another package
return "FAIL\n"
}
}
// Pkg deleted su... | func (o *jtx) removeEntry(uuid string) {
delete(o.entries, uuid)
} | func (d *Dir) RemoveEntry(name string) (entry DirEntry, err error) {
entries, err := d.ReadDir()
if err != nil {
return nil, essentials.AddCtx("RemoveEntry", err)
}
for i, entry := range entries {
if entry.Name() == name {
essentials.OrderedDelete(&entries, i)
return entry, essentials.AddCtx("RemoveEntry"... | func (t *Acl_Interface_EgressAclSet) DeleteAclEntry(SequenceId uint32) {
key := SequenceId
delete(t.AclEntry, key)
} | func deleteRegistrationEntry(ctx context.Context, r entryv1.EntryClient, entryID string) error {
resp, err := r.BatchDeleteEntry(ctx, &entryv1.BatchDeleteEntryRequest{Ids: []string{entryID}})
if err != nil {
return err
}
// These checks are purely defensive
switch {
case len(resp.Results) > 1:
return errors.N... | func (t *Acl_Interface_IngressAclSet) DeleteAclEntry(SequenceId uint32) {
key := SequenceId
delete(t.AclEntry, key)
} | func (pool *serverPool) removeEntry(entry *poolEntry) {
pool.newSelect.remove((*discoveredEntry)(entry))
pool.knownSelect.remove((*knownEntry)(entry))
entry.removed = true
delete(pool.entries, entry.node.ID())
} | func (entry *Entry) DELETE() *Entry {
entry.handlers[delete] = entry.handler
return entry
} | func (c *FwZone) Delete(vsys string, e ...interface{}) error {
names := make([]string, len(e))
for i := range e {
switch v := e[i].(type) {
case string:
names[i] = v
case Entry:
names[i] = v.Name
default:
return fmt.Errorf("Unsupported type to delete: %s", v)
}
}
path := c.xpath(vsys, names)
re... | func EntryDeleteFromReader(reader io.Reader) (*EntryDelete, error) {
var dID [2]byte
_, idErr := io.ReadFull(reader, dID[:])
if idErr != nil {
return nil, idErr
}
return &EntryDelete{
id: dID,
Base: Base{
mType: TypeEntryDelete,
mData: dID[:],
},
}, nil
} | func (o *EarthquakeEpicenter) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if o == nil {
return 0, errors.New("models: no EarthquakeEpicenter provided for delete")
}
if err := o.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
args := queries.ValuesFromMapping(reflect.I... | func (m *WindowsUpdatesCatalogEntriesCatalogEntryItemRequestBuilder) Delete(ctx context.Context, requestConfiguration *WindowsUpdatesCatalogEntriesCatalogEntryItemRequestBuilderDeleteRequestConfiguration)(error) {
requestInfo, err := m.ToDeleteRequestInformation(ctx, requestConfiguration);
if err != nil {
... | func (g *BoardsMetaSubmissionAddresses) Remove(w http.ResponseWriter, r *http.Request) {
bpk, e := misc.GetPubKey(r.FormValue("board"))
if e != nil {
send(w, e.Error(), http.StatusBadRequest)
return
}
address := r.FormValue("address")
if address == "" {
send(w, "no submission address provided", http.StatusBa... | func (InviteDelete) EntryType() EntryType { return EntryTypeInviteDelete } | [
"0.69203144",
"0.6792956",
"0.6768249",
"0.6765464",
"0.6715999",
"0.6708745",
"0.6668839",
"0.6655625",
"0.6638685",
"0.6562257",
"0.6548033",
"0.6497576",
"0.6430557",
"0.6428571",
"0.6423033",
"0.6381899",
"0.63177425",
"0.6261717",
"0.6227354",
"0.6177144",
"0.6139302",
... |
DeleteMultipleEntries deletes one or more entries from one or more existing boards. | func (s *BoardService) DeleteMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, "... | func (h *Handler) DeleteEntries(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
// Make sure session still valid
h.auth.MustAuthenticateUser(r)
// Decode request
var ids []int
err := json.NewDecoder(r.Body).Decode(&ids)
checkError(err)
// Start transaction
// Make sure to rollback if panic eve... | func (a *Client) DeleteMultiple(params *DeleteMultipleParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteMultipleOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteMultipleParams()
}
result, err := a.transport.Submit(&runtime.ClientOperation{
ID: "... | func DeleteMultiple(db persistance.Client, users []models.User) error {
return db.DeleteUsers(users)
} | func (s *FiltersService) DeleteMultiple(ids []int) (*Response, error) {
req, err := s.client.NewRequest(http.MethodDelete, "/filter", &DeleteMultipleOptions{
Ids: arrayToString(ids, ","),
}, nil)
if err != nil {
return nil, err
}
return s.client.Do(req, nil)
} | func deleteEntriesForUpdate(list []AccessListDefinition, projectID string, client *mongodbatlas.Client) handler.ProgressEvent {
for _, accessListEntry := range list {
entry, err := getEntry(accessListEntry)
if err != nil {
return progressevents.GetFailedEventByResponse(fmt.Sprintf("Error getting the resource: %... | func (s *BoardService) DeleteEntry(BoardIDs []string, entryID string) (*http.Response, error) {
bodyJSON := &struct {
EntryID string `json:"entryId,omitempty"`
}{
EntryID: entryID,
}
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).BodyJSON(body... | func DeleteMulti(c appengine.Context, key []*datastore.Key) error {
errm := memcache.DeleteMulti(c, encodeKeys(key))
errd := datastore.DeleteMulti(c, key)
if errd != nil {
return errd
}
return errm
} | func (s *OrganizationFieldsService) DeleteMultiple(ctx context.Context, ids []int) (*Response, error) {
req, err := s.client.NewRequest(http.MethodDelete, "/organizationFields", &DeleteMultipleOptions{
Ids: arrayToString(ids, ","),
}, nil)
if err != nil {
return nil, err
}
return s.client.Do(ctx, req, nil)
} | func DelMulti(keys []string) error {
return defMgr.Default().DelMulti(keys)
} | func (c *CentralConfigCacheImpl) DeleteBatch(keys []string) error {
return ErrUnsupportedOperation
} | func DeleteBeans(ctx context.Context, beans ...any) (err error) {
e := GetEngine(ctx)
for i := range beans {
if _, err = e.Delete(beans[i]); err != nil {
return err
}
}
return nil
} | func (c Client) DeleteMultipleIncidents(paramType, paramValue string, includeUnacknowledged bool) (err error) {
switch paramType {
case "flock_id", "node_id", "src_host", "older_than", "filter_str", "filter_logtypes":
default:
return errors.New("unsupported parameter for DeleteMultipleIncidents: " + paramType)
}
... | func (c *Client) DeleteMulti(ctx context.Context, keys []*datastore.Key) error {
if err := c.DSClient.DeleteMulti(ctx, keys); err != nil {
return fmt.Errorf("dscache.Client.DeleteMulti: failed to delete %v", err)
}
cKeys := make([]string, len(keys))
for i, key := range keys {
cKeys[i] = cacheKey(key)
}
// De... | func (c *Client) DeleteEntityEntries(eidOrName string, entries []string) (result ApiResponse, err error) {
var bytes []byte
if bytes, err = c.httpDelete(fmt.Sprintf("entities/%s/entries", eidOrName), nil, nil, entries); err == nil {
if err = json.Unmarshal(bytes, &result); err == nil {
return result, nil
}
}
... | func (c *MemCached) DelMulti(keys []string) error {
for _, key := range c.BuildKeys(keys) {
if err := c.client.Delete(key); err != nil {
return err
}
}
return nil
} | func (s *BoardService) AddMultipleEntries(BoardIDs []string, entryIDs []string) (*http.Response, error) {
bodyJSON := &struct {
EntryIds []string `json:"entryIds,omitempty"`
}{
EntryIds: entryIDs,
}
apiError := new(APIError)
resp, err := s.sling.New().Put("tags/"+url.PathEscape(strings.Join(BoardIDs, ","))).... | func (c *BuntDB) DelMulti(keys []string) error {
return c.db.Update(func(tx *buntdb.Tx) (err error) {
for _, k := range keys {
if _, err = tx.Delete(k); err != nil {
return err
}
}
return nil
})
} | func (a *Client) DeleteMultipleDatabasesByCrn(params *DeleteMultipleDatabasesByCrnParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteMultipleDatabasesByCrnOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteMultipleDatabasesByCrnParams()
}
result, err := a.transport.... | func (f *Client) DeleteMulti(context.Context, []*datastore.Key) (err error) {
panic("unimplemented")
} | func (objectStorage *ObjectStorage) DeleteEntriesFromStore(keys [][]byte) error {
if !objectStorage.options.persistenceEnabled {
return nil
}
batchedMuts, err := objectStorage.options.store.Batched()
if err != nil {
return err
}
for i := 0; i < len(keys); i++ {
if err := batchedMuts.Delete(keys[i]); err !... | func DeleteMulti(keys []string) map[string]error {
return DefaultCache.DeleteMulti(keys)
} | func (api *API) DeleteWorkersKVEntries(ctx context.Context, rc *ResourceContainer, params DeleteWorkersKVEntriesParams) (Response, error) {
uri := fmt.Sprintf("/accounts/%s/storage/kv/namespaces/%s/bulk", rc.Identifier, params.NamespaceID)
res, err := api.makeRequestContextWithHeaders(
ctx, http.MethodDelete, uri, ... | func (o BoardSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if len(o) == 0 {
return 0, nil
}
if len(boardBeforeDeleteHooks) != 0 {
for _, obj := range o {
if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
}
}
var args []interface{}
for ... | func deleteBeans(e Engine, beans ...interface{}) (err error) {
for bean := range beans {
if _, err = e.Delete(bean); err != nil {
return err
}
}
return nil
} | func (s *LocalStorage) DeleteBatch(prefix []byte, keys [][]byte) error {
wb := s.db.NewWriteBatch()
defer wb.Cancel()
for _, origKey := range keys {
key := make([]byte, len(prefix)+len(origKey))
copy(key[:len(prefix)], prefix)
copy(key[len(prefix):], origKey)
err := wb.Delete(key)
if err != nil {
retu... | func (immutable *Immutable) Delete(entries ...Entry) (*Immutable, Entries) {
if len(entries) == 0 {
return immutable, Entries{}
}
deleted := make(Entries, 0, len(entries))
cp := immutable.copy()
for _, e := range entries {
deleted = append(deleted, cp.delete(e))
}
return cp, deleted
} | func (ndns *NoopDNS) deleteEntries(name string, entries *Entries) error {
return nil
} | func (c *MemoryCache) DelMulti(keys []string) error {
c.lock.Lock()
for _, key := range keys {
_ = c.del(key)
}
c.lock.Unlock()
return nil
} | func (gm *Gonm) DeleteMulti(dst interface{}) error {
keys, err := extractKeys(dst, false) // allow incomplete keys on a Put request
if err != nil {
return gm.stackError(err)
}
goroutines := (len(keys)-1)/datastorePutMultiMaxItems + 1
var multiError datastore.MultiError
var eg errgroup.Group
for i := 0; i < g... | func (a *Client) DeleteCommentMultiple(params *DeleteCommentMultipleParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteCommentMultipleOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteCommentMultipleParams()
}
result, err := a.transport.Submit(&runtime.ClientOperat... | func (mr *MockGameRevisionFeatureRepositoryMockRecorder) DeleteMultiple(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiple", reflect.TypeOf((*MockGameRevisionFeatureRepository)(nil).DeleteMultiple), arg0, arg1)
} | func (e *executor) Delete(list ...interface{}) (int64, error) {
var result int64
var err error
types := types(list)
query := fmt.Sprintf("MULTI-DELETE <objects:%v>", types)
jgorp.Trace(e.ctx, e.name, query, func() error {
result, err = e.inner.Delete(list...)
return err
})
return result, err
} | func DeleteMany(
ctx context.Context,
dynamo dynamodbiface.DynamoDBAPI,
tableName *string,
ids []string,
ttl string,
) (
deletedCount int,
err error,
) {
ctx, segment := xray.BeginSubsegment(ctx, "Delete")
defer segment.Close(err)
for _, id := range ids {
// First get a list of all the Hash and Sort keys m... | func (mr *MockGameRevisionTagRepositoryMockRecorder) DeleteMultiple(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiple", reflect.TypeOf((*MockGameRevisionTagRepository)(nil).DeleteMultiple), arg0, arg1)
} | func (rc *Cache) DelMulti(keys []string) error {
if rc.conn == nil {
if err := rc.connectInit(); err != nil {
return err
}
}
_, err := rc.conn.Do("multi_del", keys)
if err != nil {
return err
}
return nil
} | func (s *BoardService) Delete(boardIDs []string) (*http.Response, error) {
apiError := new(APIError)
resp, err := s.sling.New().Delete("tags/"+url.PathEscape(strings.Join(boardIDs, ","))).Receive(nil, apiError)
return resp, relevantError(err, apiError)
} | func (m *MockGameRevisionFeatureRepository) DeleteMultiple(arg0 context.Context, arg1 []entity.GameRevisionFeature) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteMultiple", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | func (d *Dao) DelMulti(c context.Context, keys ...string) (err error) {
if len(keys) == 0 {
return
}
conn := d.cluster.Get(c)
defer conn.Close()
args := redis.Args{}
for _, k := range keys {
args = args.Add(k)
}
if _, err = redis.Int(conn.Do("DEL", args...)); err != nil {
log.Error("DelMulti conn.Do(de... | func (c *Connector) MultiRemove(ctx context.Context, ei *dosa.EntityInfo, multiValues []map[string]dosa.FieldValue) ([]error, error) {
return makeErrorSlice(len(multiValues), &dosa.ErrNotFound{}), nil
} | func (a *Client) DeleteMultipleDatabaseServersByCrn(params *DeleteMultipleDatabaseServersByCrnParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteMultipleDatabaseServersByCrnOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDeleteMultipleDatabaseServersByCrnParams()
}
res... | func (mr *MockGameRevisionPublisherRepositoryMockRecorder) DeleteMultiple(arg0, arg1 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultiple", reflect.TypeOf((*MockGameRevisionPublisherRepository)(nil).DeleteMultiple), arg0, arg1)
} | func (rc *Cache) DelMulti(keys []string) error {
_, err := rc.conn.Do("multi_del", keys)
return berror.Wrapf(err, cache.SsdbCacheCurdFailed, "multi_del failed: %v", keys)
} | func (c *Client) MultiHdel(name string, keys ...interface{}) (int64, error) {
return c.doReturnInt("multi_hdel", name, keys)
} | func (c *RawBinaryClient) DeleteMulti(keys []string) []MutateResponse {
if keys == nil {
return nil
}
responses := make([]MutateResponse, len(keys), len(keys))
c.mutex.Lock()
defer c.mutex.Unlock()
for i, key := range keys {
responses[i] = c.sendDeleteRequest(key)
}
for i, key := range keys {
if respo... | func (m *MockGameRevisionTagRepository) DeleteMultiple(arg0 context.Context, arg1 []entity.GameRevisionTag) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteMultiple", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | func (c *RawClientStub) BatchDelete(keys [][]byte) error {
_, err := c.send(fmt.Sprintf("/rawkv/client/%s/batch-delete", c.id), &RawRequest{Keys: keys})
return err
} | func (q boardQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if q.Query == nil {
return 0, errors.New("model: no boardQuery provided for delete all")
}
queries.SetDelete(q.Query)
result, err := q.Query.ExecContext(ctx, exec)
if err != nil {
return 0, errors.Wrap(err, "model:... | func (c *Client) MultiDel(keys ...interface{}) (int64, error) {
return c.doReturnInt("multi_del", keys)
} | func DeleteMulti(c appengine.Context, blobKey []appengine.BlobKey) error {
s := make([]string, len(blobKey))
for i, b := range blobKey {
s[i] = string(b)
}
req := &blobpb.DeleteBlobRequest{
BlobKey: s,
}
res := &basepb.VoidProto{}
if err := c.Call("blobstore", "DeleteBlob", req, res, nil); err != nil {
ret... | func EntryDeleteFromItems(dID [2]byte) *EntryDelete {
return &EntryDelete{
id: dID,
Base: Base{
mType: TypeEntryDelete,
mData: dID[:],
},
}
} | func DeleteNextQueryEntries(ctx context.Context, tx pathdb.Transaction,
results query.Results) error {
logger := log.FromCtx(ctx)
nextQueriesToDelete := make(map[Request]struct{})
for _, r := range results {
var req Request
switch r.Type {
case proto.PathSegType_up:
req = Request{Src: r.Seg.LastIA(), Dst:... | func (mp *metaPartition) DeleteDentryBatch(req *BatchDeleteDentryReq, p *Packet) (err error) {
db := make(DentryBatch, 0, len(req.Dens))
for _, d := range req.Dens {
db = append(db, &Dentry{
ParentId: req.ParentID,
Name: d.Name,
Inode: d.Inode,
Type: d.Type,
})
}
val, err := db.Marshal... | func (c *Collection) DeleteMany(ids []core.InstanceID, opts ...TxnOption) error {
return c.WriteTxn(func(txn *Txn) error {
return txn.Delete(ids...)
}, opts...)
} | func (m *XORMManager) BulkDeleteDashboard(dashboards []*models.Dashboard) error {
// Xorm does not support bulk delete
if len(dashboards) > 0 {
query, queryParams := getBulkDeleteDashboardQuery(dashboards)
_, err := engine.Exec(query, queryParams...)
return err
}
return nil
} | func DeleteItems(w http.ResponseWriter, r *http.Request, dbCoords database.ConnCoordinates, opts ...interface{}) {
del := func(i *database.Item, db *sqlite3.Conn) {
i.Delete(db)
}
processItems(w, r, dbCoords, del, "/")
} | func DeleteItems(w http.ResponseWriter, r *http.Request, dbCoords database.ConnCoordinates, opts ...interface{}) {
del := func(i *database.Item, db *sqlite3.Conn) {
i.Delete(db)
}
processItems(w, r, dbCoords, del, "/")
} | func BulkDeleteRuns(db *gorm.DB, bulkQuery *models.BulkDeleteRunRequest) error {
return Batch(func(_, limit uint) (count uint, err error) {
res := db.Exec(`
WITH job_runs_to_delete AS (
SELECT id FROM job_runs jr
WHERE jr.status IN (?) AND jr.updated_at < ?
ORDER BY jr.id ASC
LIMIT ?
),
deleted_task_runs AS (
D... | func (h *Host) DeleteHostBatch(hostID string) error {
data := common.CreateCondition().Field("bk_host_id").Eq(hostID)
targetURL := fmt.Sprintf("%s/api/v3/hosts/batch", h.cli.GetAddress())
rst, err := h.cli.httpCli.DELETE(targetURL, nil, data.ToMapStr().ToJSON())
if nil != err {
return err
}
gs := gjson.ParseB... | func (c *Connector) MultiRemove(ctx context.Context, ei *dosa.EntityInfo, multiKeys []map[string]dosa.FieldValue) ([]error, error) {
keyValues, err := multiKeyValuesToRPCValues(multiKeys)
if err != nil {
return nil, err
}
// perform the multi remove request
request := &dosarpc.MultiRemoveRequest{
Ref: e... | func (c *Client) DeleteMessages(
channelID discord.Snowflake, messageIDs []discord.Snowflake) error {
var param struct {
Messages []discord.Snowflake `json:"messages"`
}
param.Messages = messageIDs
return c.FastRequest("POST", EndpointChannels+channelID.String()+
"/messages/bulk-delete", httputil.WithJSONBo... | func (cs *CacheStorage) RemoveEntries(first, last uint64) error {
cs.l.Lock()
// TODO Don't invalidate key-values.
cs.stateCache = make(map[uint64]uint64)
cs.logCache = make([]*commonpb.Entry, len(cs.logCache))
cs.l.Unlock()
return cs.s.RemoveEntries(first, last)
} | func (g *Gosto) DeleteMulti(keys []*datastore.Key) error {
if len(keys) == 0 {
return nil
}
mu := new(sync.Mutex)
multiErr, any := make(datastore.MultiError, len(keys)), false
goroutines := (len(keys)-1)/deleteMultiLimit + 1
var wg sync.WaitGroup
wg.Add(goroutines)
for i := 0; i < goroutines; i++ {
go func... | func (s *stubDBManager) DeleteMany(ctx context.Context, filter interface{}, db, col string) (int, error) {
collection := s.client.Database(db).Collection(col)
result, err := collection.DeleteMany(ctx, filter)
if err != nil {
return 0, err
}
return int(result.DeletedCount), nil
} | func (a *Client) DcimPlatformsBulkDelete(params *DcimPlatformsBulkDeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DcimPlatformsBulkDeleteNoContent, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewDcimPlatformsBulkDeleteParams()
}
op := &runtime.Clie... | func (m *MockGameRevisionPublisherRepository) DeleteMultiple(arg0 context.Context, arg1 []entity.GameRevisionPublisher) error {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "DeleteMultiple", arg0, arg1)
ret0, _ := ret[0].(error)
return ret0
} | func (dal DataAccessLayerImpl) BatchDelete(ctx context.Context, keys [][]byte) error {
cli := dal.rawKV.GetClient().(*rawkv.Client)
return cli.BatchDelete(ctx, keys)
} | func (repo CapitalRepository) DeleteMany(ctx context.Context, filters []ListFilter, tx *sql.Tx, autocommit bool) error {
var (
err error
stmt *sql.Stmt
segments []string
values []interface{}
)
if tx == nil {
if err = util.CheckContext(ctx); err != nil {
return err
}
tx, err = repo.db.Be... | func (db *Database) RemoveMissingEntries(entryIdMapWhitelist map[string]bool, addedPaths []string) (int, int, error) {
var removed, merged int
namesToEntryIDs := make(map[string]string, len(addedPaths))
for _, path := range addedPaths {
namesToEntryIDs[filepath.Base(path)] = getEntryId(path)
}
err := db.bdb.Up... | func (r *ReplicationsService) DeleteMultiPush(repo string, url string) (*string, *Response, error) {
u := fmt.Sprintf("/api/replications/%s?url=%s", repo, url)
v := new(string)
resp, err := r.client.Call("DELETE", u, nil, v)
return v, resp, err
} | func (a *Client) RemoveTagsMultiple(params *RemoveTagsMultipleParams, authInfo runtime.ClientAuthInfoWriter) (*RemoveTagsMultipleOK, error) {
// TODO: Validate the params before sending
if params == nil {
params = NewRemoveTagsMultipleParams()
}
result, err := a.transport.Submit(&runtime.ClientOperation{
ID: ... | func (o EarthquakeEpicenterSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if len(o) == 0 {
return 0, nil
}
if len(earthquakeEpicenterBeforeDeleteHooks) != 0 {
for _, obj := range o {
if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
}
}
... | func (o CommandInfoSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) error {
if len(o) == 0 {
return nil
}
var args []interface{}
for _, obj := range o {
pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), commandInfoPrimaryKeyMapping)
args = append(args, pkeyArgs...)... | func (r *ChannelResource) DeleteMessageBulk(ctx context.Context, messageIDs []string) error {
st := struct {
Messages []string `json:"messages"`
}{
Messages: messageIDs,
}
b, err := json.Marshal(st)
if err != nil {
return err
}
e := endpoint.BulkDeleteMessage(r.channelID)
resp, err := r.client.doReq(ctx,... | func DeleteObjectStoreEntries(databaseName string, objectStoreName string, keyRange *KeyRange) *DeleteObjectStoreEntriesParams {
return &DeleteObjectStoreEntriesParams{
DatabaseName: databaseName,
ObjectStoreName: objectStoreName,
KeyRange: keyRange,
}
} | func (logDB *LoggerDB) CleanQueryLogs(entries int64) error {
// TODO this would be better and simpler with foreign keys and delete cascade
// Find queries to delete with OFFSET
var oldQueries []queries.DistributedQuery
logDB.Database.Conn.Offset(int(entries)).Find(&oldQueries)
for _, q := range oldQueries {
if q... | func (api *API) MaintenancesDeleteByIDs(ids []string) (err error) {
response, err := api.CallWithError("maintenance.delete", ids)
if err != nil {
return
}
result := response.Result.(map[string]interface{})
maintenanceids := result["maintenanceids"].([]interface{})
if len(ids) != len(maintenanceids) {
err = &... | func (d *sqldb) Del(ids []uint64) error {
phs := make([]string, len(ids))
args := make([]interface{}, len(ids))
for i := range ids {
phs[i] = "?"
args[i] = ids[i]
}
query := fmt.Sprintf("delete from t where id in (%s)", strings.Join(phs, ","))
_, err := d.Exec(query, args...)
return err
} | func DeleteMultiElementsBadRequest(t goatest.TInterface, ctx context.Context, service *goa.Service, ctrl app.ElementsController, listID string, elementIds []string) (http.ResponseWriter, error) {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interf... | func (v *QuestionDAO) BatchDelete(ctx context.Context, ids []string) ([]string, error) {
var deletedIDs []string
for _, id := range ids {
err := v.Delete(ctx, id)
if err != nil {
return nil, err
}
deletedIDs = append(deletedIDs, id)
}
return deletedIDs, nil
} | func (iu *InputUpdate) ClearMultiple() *InputUpdate {
iu.mutation.ClearMultiple()
return iu
} | func (mr *MockExtendedK8sClientMockRecorder) DeleteMultipleOpenShiftSCC(arg0, arg1, arg2 interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMultipleOpenShiftSCC", reflect.TypeOf((*MockExtendedK8sClient)(nil).DeleteMultipleOpenShiftSCC), arg0, arg1, arg2)
} | func DeleteBFDs(nbClient libovsdbclient.Client, bfds ...*nbdb.BFD) error {
opModels := make([]operationModel, 0, len(bfds))
for i := range bfds {
bfd := bfds[i]
opModel := operationModel{
Model: bfd,
ErrNotFound: false,
BulkOp: false,
}
opModels = append(opModels, opModel)
}
m := newMod... | func DeleteElements(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
req := new(deleteReq)
if r.Body == nil {
http.Error(w, "Please send a request body", 400)
return
}
err := json.NewDecoder(r.Body).Decode(&req)
if err != nil {
fmt.Println("error json")
http.Error(w, err.Error(), 400)
ret... | func (cr *SearchController) DeleteMany(cx *goweb.Context) {
cx.RespondWithStatus(http.StatusForbidden)
} | func (t *Table) DeleteIDs(args ...any) (int, error) {
if len(args) == 0 {
return 0, nil
}
if len(args) == 1 {
args = expandSlice(args[0])
}
if len(args) == 0 {
return 0, nil
}
af, err := t.Exec(fmt.Sprintf("DELETE FROM `%s` WHERE id IN(%s)", t.tableName, placeholder(len(args))), args...).RowsAffected()
re... | func (svc *DynamoDB) XBatchDeleteItems(ctx context.Context, req XBatchDeleteItemRequest) error {
tableName := req.TableName
hashKey := req.HashKey
rangeKey := req.RangeKey
var errs errors.ErrorList
itemChunks := req.ToChunks()
for _, items := range itemChunks {
writeReq := make([]WriteRequest, len(items))
fo... | func (db *gomgo) DeleteMany(collectionName string, selector interface{}) (err error) {
sessionClone := db.conn.Session.Copy()
defer sessionClone.Close()
collection := sessionClone.DB(db.conn.Name).C(collectionName)
_, err = collection.RemoveAll(selector)
if err != nil {
return err
}
return nil
} | func (c *CollectionsClient) DeleteMany(ctx context.Context, collection string, ids ...string) (*BaseResponse, error) {
if collection == "" {
return nil, errors.New("collection name required")
}
endpoint := c.client.makeEndpoint("collections/")
endpoint.addQueryParam(makeRequestOption("collection_name", collection... | func (c *Nomad) DeleteConfigs() error {
for _, host := range append(c.Cfg.Clients, c.Cfg.Servers...) {
_, err := ssh.Ssh(host, c.Cfg, "bash -c \"rm -rf /etc/nomad.d\"")
if err != nil {
return err
}
}
return nil
} | func Delete(opt Opt, ids ...int) {
db := openDB(opt)
for _, id := range ids {
err := db.Delete(id)
cli.Check(err)
}
} | func (t *TodoList) Delete(ids ...int) {
for _, id := range ids {
todo := t.FindByID(id)
if todo == nil {
continue
}
i := -1
for index, todo := range t.Data {
if todo.ID == id {
i = index
}
}
t.Data = append(t.Data[:i], t.Data[i+1:]...)
}
} | func (mr *MockCacheMockRecorder) DeleteMulti(ctx, projectID, keys interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMulti", reflect.TypeOf((*MockCache)(nil).DeleteMulti), ctx, projectID, keys)
} | func (l *PerSubDigestStore) DeleteDigests(networks []string) error {
store, err := l.fact.StartTransaction(nil)
if err != nil {
return errors.Wrap(err, "error starting transaction")
}
defer store.Rollback()
errs := &multierror.Error{}
for _, network := range networks {
err = store.Delete(perSubDigestBlobstor... | func (st DBstore) DeleteAlertInstances(ctx context.Context, keys ...models.AlertInstanceKey) error {
if len(keys) == 0 {
return nil
}
type data struct {
ruleOrgID int64
ruleUID string
labelHashes []interface{}
}
// Sort by org and rule UID. Most callers will have grouped already, but it's
// cheap... | func RemoveCronEntries(scheduler *cron.Cron) {
for _, entry := range scheduler.Entries() {
scheduler.Remove(entry.ID)
}
} | func DeleteMultiElementsNotFound(t goatest.TInterface, ctx context.Context, service *goa.Service, ctrl app.ElementsController, listID string, elementIds []string) (http.ResponseWriter, error) {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interfac... | func (sm *SortedMap) BatchDelete(keys []interface{}) []bool {
results := make([]bool, len(keys))
for i, key := range keys {
results[i] = sm.delete(key)
}
return results
} | func (o HomeLinkinfoSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) {
if len(o) == 0 {
return 0, nil
}
if len(homeLinkinfoBeforeDeleteHooks) != 0 {
for _, obj := range o {
if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil {
return 0, err
}
}
}
var args []int... | func DeleteMultiElementsNoContent(t goatest.TInterface, ctx context.Context, service *goa.Service, ctrl app.ElementsController, listID string, elementIds []string) http.ResponseWriter {
// Setup service
var (
logBuf bytes.Buffer
respSetter goatest.ResponseSetterFunc = func(r interface{}) {}
)
if service == nil... | func (s GroupMemberSet) Delete(items ...*GroupMember) {
for _, item := range items {
delete(s, normalizeGroupMember(item))
}
} | [
"0.7129575",
"0.64574975",
"0.6167691",
"0.61338776",
"0.600981",
"0.5890097",
"0.58407915",
"0.58175015",
"0.5813697",
"0.5774256",
"0.5764174",
"0.57505935",
"0.57422537",
"0.5737383",
"0.5724166",
"0.57117087",
"0.5698028",
"0.565721",
"0.56508166",
"0.56451756",
"0.561477... |
Details returns details about a board. | func (s *BoardService) Details(boardID string) (*BoardDetailResponse, *http.Response, error) {
encodedResponse := make([]map[string]interface{}, 0)
decodedResponse := new(BoardDetailResponse)
apiError := new(APIError)
resp, err := s.sling.New().Get("boards/"+url.PathEscape(boardID)).Receive(&encodedResponse, apiEr... | func Info() BaseBoard {
baseboard, err := ghw.Baseboard()
if err != nil {
fmt.Printf("Error getting product info: %v", err)
}
return BaseBoard{
Vendor: baseboard.Vendor,
AssetTag: baseboard.AssetTag,
SerialNumber: baseboard.SerialNumber,
Version: baseboard.Version,
}
} | func (*BoardDetailsResponse) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_board_proto_rawDescGZIP(), []int{1}
} | func (g Glo) GetBoard(id string, fields []string) (board Board) {
resp := g.callAPI("GET", g.pathBoards+"/"+id, fields, nil)
if resp.Ok {
err := resp.JSON(&board)
if err != nil {
log.Fatal("Unmarshal error")
}
}
return
} | func PrintBoard(board Board) {
ClearScreen()
fmt.Println("to exit, type 'exit'")
var i, j int
s := "\r\n "
for i = 0; i < board.Width; i++ {
s += strconv.Itoa(i+1) + " "
}
fmt.Printf(s + "\r\n")
for j = 0; j < board.Height; j++ {
s = " " + strconv.Itoa(j+1) + " "
for i = 0; i < board.Width; i++ {
... | func NewBoard(cfg config.KeyValueStore) (r *board, err error) {
var dbFactory func(uint16) (driver.DB, error)
if cfg.LevelDB != nil {
dbFactory = func(boardId uint16) (driver.DB, error) {
dbcfg := *cfg.LevelDB
dbcfg.Path += fmt.Sprintf("-%04x", boardId)
return driver.NewLevelDB(dbcfg)
}
}
if err != nil... | func (c *Client) GetBoard(product string) (Board, error) {
// set timeout timer by context package.
ctx, cancel := context.WithTimeout(context.Background(), timeout*time.Second)
defer cancel()
// prepare query parameters.
vals := url.Values{}
if product != "" {
vals.Add("product_code", product)
}
// make ne... | func (o *Board) String() string {
return fmt.Sprintf("work.Board<%s>", o.ID)
} | func (*BoardDetailsRequest) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_board_proto_rawDescGZIP(), []int{0}
} | func (b *Board) PrintBoard() {
fmt.Println(" a b c d e f g h")
for rank := 8; rank > 0; rank-- {
fmt.Println(" +---+---+---+---+---+---+---+---+")
fmt.Print(" |")
for file := 1; file <= 8; file++ {
fmt.Print(" ", PieceNames[b.Squares[Index[file][rank]]]+"|")
}
fmt.Println(rank)
}
fmt... | func NewBoard() Board {
b := Board{}
b.Tris[0] = Triangle{White: 2}
b.Tris[5] = Triangle{Black: 5}
b.Tris[7] = Triangle{Black: 3}
b.Tris[11] = Triangle{White: 5}
b.Tris[12] = Triangle{Black: 5}
b.Tris[16] = Triangle{White: 3}
b.Tris[18] = Triangle{White: 5}
b.Tris[23] = Triangle{Black: 2}
return b
} | func NewBoard(name string, isSystem, isClosed bool, now time.Time) *Board {
return &Board{
ID: "board_" + common.GenerateID(),
Name: name,
DispOrder: 0,
IsSystem: isSystem,
IsClosed: isClosed,
CreatedDate: now,
Version: 1,
}
} | func (r Repo) GetBoard() core.Board {
board := core.Board{}
stateMap := make(map[string]*core.State)
// stateProps stores all states and their IDs
stateProps := []struct {
Name string
ID string
}{}
var stateName, stateID, title, desc, deadline, id, ticketStateID string
var priority, limit, position int
... | func (b Board) Show() {
fmt.Print(b.String())
} | func (c *Controller) ReadBoard() string {
return c.terminal.GetBoardText(false)
} | func newBoard() *Board {
return &Board{Fields: [nRows][nCols]color{}, NextColor: red, winner: none}
} | func (a *Analyzer) GetBoard() *board.Board {
return a.board
} | func NewBoard() *Board {
b := &Board{}
b.SetupPieces()
return b
} | func NewBoard() Board {
var b boardImpl
b.init(Edit)
return &b
} | func NewBoard() *Board {
b := new(Board)
setBoard(b)
return b
} | func getCardDetails(c echo.Context) error {
return sendGETReqToGH("https://api.github.com/projects/columns/cards/"+c.Param("cardID"), c)
} | func (bo *Board) String() string {
var buf bytes.Buffer
// write header
fmt.Fprint(&buf, " ")
for i := 0; i < bo.Width(); i++ {
fmt.Fprintf(&buf, " %2d", i)
}
fmt.Fprint(&buf, "\n\n")
// Write each line
for i, row := range bo.Grid {
fmt.Fprintf(&buf, "%2d ", i)
for _, sq := range row {
if IsGiven... | func NewBoard() {
board = &Board{}
board.Clear()
} | func (t *Github) Details(i *messages.Issue) *Issue {
gIssue, _, _ := t.client.Issues.Get(i.Org, i.Repo, i.Number)
opt := github.IssueListCommentsOptions{}
gComments, _, _ := t.client.Issues.ListComments(i.Org, i.Repo, i.Number, &opt)
issue := t.mapIssue(gIssue)
if issue != nil {
issue.Comments = t.mapComments(&... | func (b Board) PrintBoard() {
for _, row := range b {
for _, col := range row {
fmt.Printf("%v ", col)
}
fmt.Println("")
}
for _ = range b[0] {
fmt.Print("- ")
}
fmt.Println("")
} | func NewBoard() *Board {
var board Board
board.Init()
return &board
} | func (*BoardListItem) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_board_proto_rawDescGZIP(), []int{20}
} | func NewBoard(difficulty string) *Board {
params, ok := boardDefinitionsDict()[difficulty]
// unrecognized board types rejected
if !ok {
return nil
}
retval := new(Board)
retval.difficulty, retval.rows, retval.cols, retval.mineCount = difficulty, params.rows, params.cols, params.mineCount
return retval
} | func NewBoard(cube *Cube) *Board {
return &Board{
cube: cube,
rowMap: make(map[string]*Row),
}
} | func (board *Board) printDebugBoard() {
for j := 0; j < board.height; j++ {
for i := 0; i < board.width; i++ {
switch board.colors[i][j] {
case colorBlank:
fmt.Print(".")
case colorBlue:
fmt.Print("B")
case colorCyan:
fmt.Print("C")
case colorGreen:
fmt.Print("G")
case colorMagenta:... | func (uci *UCI) PrintBoard() {
uci.Engine.Position.PrintBoard()
} | func (p *parser) GetDetails(a *goquery.Selection) *model.Club {
d := detail{area: a, cleanImg: p.cleanImg}
d.setID()
d.setName()
d.setImage()
d.setInformation()
d.setMember()
d.setPicture()
d.setCategory()
d.setDate()
d.setDetail()
d.setType()
return &d.data
} | func NewBoard() *Board {
return &Board{
board: [64]uint8{
R | White, N | White, B | White, Q | White,
K | White, B | White, N | White, R | White,
P | White, P | White, P | White, P | White,
P | White, P | White, P | White, P | White,
0, 0, 0, 0, 0,... | func FindBoard(ctx context.Context, exec boil.ContextExecutor, iD int, selectCols ...string) (*Board, error) {
boardObj := &Board{}
sel := "*"
if len(selectCols) > 0 {
sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",")
}
query := fmt.Sprintf(
"select %s from `boards` where ... | func (b Board) String() string {
switch b {
case BoardJawbreaker:
return "Jawbreaker"
case BoardHackRfOne:
return "HackRf One"
case BoardInvalid:
return "invalid"
default:
return "unknown"
}
} | func (board *Board) PrintBoard() {
for i, row := range board.Spots {
for j, spot := range row {
if spot != uint8(0) {
fmt.Printf("%v ", spot)
} else {
fmt.Print(" ")
}
if j%3 == 2 && j != 8 {
fmt.Print("|")
}
}
fmt.Print("\n")
if i%3 == 2 && i != 8 {
fmt.Println("------|------|-... | func (o *ComputeBladeAllOf) GetBoardOk() (*ComputeBoardRelationship, bool) {
if o == nil || o.Board == nil {
return nil, false
}
return o.Board, true
} | func ListBoard(w http.ResponseWriter, r *http.Request) {
token, err := r.Cookie("token")
var sc = securecookie.New(hashKey, blockKey)
value := make(map[string]string)
if err = sc.Decode("token", token.Value, &value); err == nil {
var boards []Board
var dbboards []DBBoard
var err error
q := dbsession.Select... | func NewBoard(tiles [][]int8, size int8, heuristicType int8) *Board {
f := Board{tiles, size, nil, 0, -1, heuristicType}
return &f
} | func NewBoard() *Board {
posToPiece := map[Pos]*Piece{
// White
{0, 0}: {Rook, White},
{1, 0}: {Knight, White},
{2, 0}: {Bishop, White},
{3, 0}: {Queen, White},
{4, 0}: {King, White},
{5, 0}: {Bishop, White},
{6, 0}: {Knight, White},
{7, 0}: {Rook, White},
// Black
{0, 7}: {Rook, Black},
{1, 7}... | func CreateBoard(createBoardRequest CreateBoardRequest) (*Board, error) {
var newBoard Board
// explicitly set ID
newBoard.ID = NewBoardID()
newBoard.Name = createBoardRequest.Name
newBoard.Type = createBoardRequest.Type
newBoard.Passcode = createBoardRequest.Passcode
newBoard.Shortcode = generateRandomShortcode... | func (a Board) String() (s string) {
s = "\n"
for row := 2; row < 10; row++ {
for col := 1; col < 9; col++ {
s = s + string(a[row*10+col])
}
s = s + "\n"
}
return s
} | func (*Board) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_common_proto_rawDescGZIP(), []int{5}
} | func (board *Board) getDebugBoard() []string {
lines := make([]string, board.height)
for j := 0; j < board.height; j++ {
for i := 0; i < board.width; i++ {
switch board.colors[i][j] {
case colorBlank:
lines[j] += "."
case colorBlue:
lines[j] += "B"
case colorCyan:
lines[j] += "C"
case col... | func NewBoard(client *datadog.Client, wf *aw.Workflow) Board {
return Board{
cacheName: boardCacheName(),
client: client,
wf: wf,
}
} | func (b *Board) PrintBoard() {
fmt.Println()
if b.isUserBoard {
fmt.Println("Your board")
}
if b.hasBingo {
if b.isUserBoard {
fmt.Println("You got Bingo!")
} else {
fmt.Println("Opponent got Bingo!")
}
}
for _, cellsArray := range b.rowCells {
fmt.Println(cellsArray)
}
} | func (i Memory) GetDetails() string {
return fmt.Sprintf("Memory Details\nAvailable %v \nUsed %v \nFree %v", i.Available, i.Used, i.Free)
} | func (g Glo) GetBoardCard(boardID string, cardID string, fields []string) (card BoardCard) {
resp := g.callAPI(
"GET",
g.pathBoards+"/"+boardID+g.pathCard+"/"+cardID,
fields,
nil,
)
if resp.Ok {
err := resp.JSON(&card)
if err != nil {
log.Fatal("Unmarshal error")
}
}
return
} | func (game Game) PrintBoard() {
for i := 0; i < HEIGHT; i++ {
fmt.Println("-" + strings.Repeat("--", WIDTH))
for index := 0; index < WIDTH; index++ {
fmt.Print("|" + game.board[i][index])
}
fmt.Println("|")
}
fmt.Println("-" + strings.Repeat("--", WIDTH))
} | func (o *BillOp) Details(ctx context.Context, MemberCode string, id types.ID) (*sacloud.BillDetailsResult, error) {
rawResults := ds().Get(o.key+"Details", sacloud.APIDefaultZone, id)
if rawResults == nil {
return nil, newErrorNotFound(o.key+"Details", id)
}
results := rawResults.(*[]*sacloud.BillDetail)
var va... | func ForumDetails(w http.ResponseWriter, r *http.Request){
vars := mux.Vars(r)
slug := vars["slug"]
frm, err := getForum(slug, nil)
if err != nil {
sendError( "Can't find forum with slug " + slug + "\n", 404, &w)
return
}
resp, err := json.Marshal(frm)
if err != nil {
return
}
w.Header().Set("content-... | func getBoard(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
o, err := json.Marshal(&gameboard)
if err != nil {
w.WriteHeader(500)
} else {
w.WriteHeader(200)
w.Write(o)
}
} | func newBoard() board {
return board{
{"_", "_", "_"},
{"_", "_", "_"},
{"_", "_", "_"}}
} | func boardString(board map[int]int) (nice string) {
boardsize := config.Int["boardsize"]
boardLength := boardsize * boardsize
for field, column := 0, 0; field < boardLength; field++ {
if board[field] == config.BLACK { nice += "X" }
if board[field] == config.WHITE { nice += "O" }
if board[field] == EMPTY { nice... | func (m *BoardDAC) GetBoard(key model.BoardKey) (*model.Board, error) {
row := m.db.QueryRow(
`SELECT key, name
FROM board
WHERE key = $1`,
key,
)
boardItem := &model.Board{}
err := row.Scan(
&boardItem.Key,
&boardItem.Name,
)
return boardItem, err
} | func (board Board) String() string {
var str string = ""
var i, j int8
for i = 0; i < board.size; i++ {
for j = 0; j < board.size; j++ {
if board.tiles[i][j] != 0 {
str += fmt.Sprintf("%3d", board.tiles[i][j])
} else {
str += " "
}
}
str += "\n"
}
return str
} | func NewBoard() Game {
return &Board{
b: make([]uint, BoardSize, BoardSize), // board
s: false, // solved
e: nil, // error
}
} | func (*BoardListResponse) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_board_proto_rawDescGZIP(), []int{14}
} | func NewBoard(data []string) *Board {
rows := len(data)
cols := len(data[0])
var goals, pRow, pCol int
m := make([][]*u.Stack, rows)
for row := 0; row < rows; row++ {
m[row] = make([]*u.Stack, cols)
for col, c := range data[row] {
m[row][col] = u.NewStack()
m[row][col].Push('f')
if isFloor(c) {
... | func (g *Game) GetBoard() *models.Board {
return g.board
} | func (o *ComputeBladeAllOf) GetBoard() ComputeBoardRelationship {
if o == nil || o.Board == nil {
var ret ComputeBoardRelationship
return ret
}
return *o.Board
} | func (board Board) String() string {
jt, _ := json.Marshal(board)
return string(jt)
} | func (board Board) String() string {
var boardString string
for _, row := range board {
boardString += fmt.Sprintf("%v\r\n", row)
}
return boardString
} | func (pos *Position) Board() *Board {
return pos.board
} | func newBoard() (*board, error) {
return &b2, nil
} | func (s *BoardService) List(optionalParams *BoardListOptionalParams) (*BoardListResponse, *http.Response, error) {
if optionalParams == nil {
optionalParams = &BoardListOptionalParams{}
}
encodedResponse := make([]map[string]interface{}, 0)
decodedResponse := new(BoardListResponse)
apiError := new(APIError)
r... | func (g *GameNode) Board() *Bitboard {
if g.parent == nil {
if fen, ok := g.Headers["FEN"]; ok {
if v, ok := g.Headers["SetUp"]; ok && v == "1" {
return NewBitboard(fen)
}
}
return NewBitboard("")
}
if g.boardCached == nil {
g.boardCached = g.parent.Board()
g.boardCached.Push(g.move)
}
board... | func board(players []Player) {
for _, p := range players {
if p.name == dealer {
fmt.Printf("%s : %s\n", p.name, p.cards[0])
} else {
fmt.Printf("%s\n", p)
}
}
} | func NewBoard(width, height uint8) (Board, error) {
if height%2 != 0 {
return nil, errors.New("height must be even")
}
if width%2 != 0 {
return nil, errors.New("width must be even")
}
board := make([][]ID, width)
for w := uint8(0); w < width; w++ {
board[w] = make([]ID, height)
for h := uint8(0); h < heig... | func (board Board) String() string {
b := &strings.Builder{}
for _, line := range board {
fmt.Fprintf(b, "+-----------+\n|")
for _, num := range line {
fmt.Fprintf(b, " %s |", num)
}
fmt.Fprintln(b)
}
fmt.Fprintln(b, "+-----------+")
return b.String()
} | func printBoard(board [][]byte) {
// fmt.Println(string(board[0][1]))
fmt.Println()
for _, row := range board {
for _, cell := range row {
fmt.Print(string(cell), " ")
}
fmt.Println()
}
fmt.Print("\n")
} | func (b *BoardsService) List(ctx context.Context, opts *BoardsOptions) ([]*Board, *Response, error) {
q := QueryParameters(opts)
req, err := b.client.NewRequest("GET", "board"+q, nil)
if err != nil {
return nil, nil, err
}
var wrap = &BoardWrap{}
resp, err := b.client.Do(ctx, req, wrap)
if err != nil {
re... | func (candidateBoard CandidateBoard) String() string {
var boardString string
for _, row := range candidateBoard {
for _, col := range row {
if len(col) > 1 {
boardString += fmt.Sprintf("[ ")
for key := range col {
boardString += fmt.Sprintf("%#v ", key)
}
boardString += fmt.Sprintf("] ")
... | func Baseboard(opts ...*WithOption) (*BaseboardInfo, error) {
mergeOpts := mergeOptions(opts...)
ctx := &context{
chroot: *mergeOpts.Chroot,
}
info := &BaseboardInfo{}
if err := ctx.baseboardFillInfo(info); err != nil {
return nil, err
}
return info, nil
} | func (d *Drisqus) ForumDetails(ctx context.Context, forumID string) (*gisqus.Forum, error) {
values := url.Values{}
forum, err := d.gisqus.ForumDetails(ctx, forumID, values)
if err != nil {
return nil, err
}
return forum.Response, nil
} | func (g *GitInfo) Details(ctx context.Context, hash string, includeBranchInfo bool) (*vcsinfo.LongCommit, error) {
g.mutex.Lock()
defer g.mutex.Unlock()
return g.details(ctx, hash, includeBranchInfo)
} | func Board(board [][]byte) (boardString string) {
for _, row := range board {
for i, cell := range row {
end := " "
if i == len(row)-1 {
end = "\n"
}
boardString += string(cell) + end
}
}
return
} | func (favt *FavItem) GetBoard() *FavBoardItem {
if ret, ok := favt.Item.(*FavBoardItem); ok {
return ret
}
return nil
} | func (m *BoardDAC) GetBoardList() ([]*model.Board, error) {
rows, err := m.db.Query(`SELECT key, name FROM board`)
if err != nil {
return nil, err
}
boardList := make([]*model.Board, 0)
for rows.Next() {
boardItem := &model.Board{}
err = rows.Scan(&boardItem.Key, &boardItem.Name)
boardList = append(boardLi... | func PrintBoard(pos *Board) {
fmt.Printf("\nGame Board:\n\n")
log.Printf("\nGame Board:\n\n")
for rank := Rank8; rank >= Rank1; rank-- {
fmt.Printf("%d ", rank+1)
log.Printf("%d ", rank+1)
for file := FileA; file <= FileH; file++ {
sq := FileRankToSquare(file, rank)
piece := pos.Pieces[sq]
fmt.Prin... | func (brd *BoardService) List() []domain.Board {
return brd.boards
} | func GetBoard(target string) *Board {
for _, b := range boards {
if b.target == target {
return b
}
}
return nil
} | func NewBoard(ctx context.Context, db *bbolt.DB, ec chan error) (*CommodityBoard, error) {
// open I2C bus+device
b, err := i2creg.Open(I2CBus)
if err != nil {
return nil, err
}
d := &i2c.Dev{Addr: uint16(I2CAddr), Bus: b}
// t3h board
board := &CommodityBoard{
db: db,
ec: ec,
mux: &sync.Mutex{},
... | func GenerateBoard(difficulty int) MemoryGame {
log.Printf("memorygame.go > GenerateBoard [ %v ]", difficulty)
//This var will contain, after an initial generation, all the
//pieces which could be converted to queens
var convertiblePieces []Piece
//Difficulty variable
diff := difficulty
//Time before hiding the ... | func (b Board) CheckBoard() string {
lines := [][]int{
line{0, 1, 2},
line{3, 4, 5},
line{6, 7, 8},
line{0, 3, 6},
line{1, 4, 7},
line{2, 5, 8},
line{0, 4, 8},
line{2, 4, 6},
}
for _, l := range lines {
x0, x1, x2 := l[0], l[1], l[2]
if b[x1] == b[x2] && b[x0] == b[x1] && b[x0] == b[x2] {
re... | func GetBoard(grid [][]int, player int, selectedCube Cube) Board {
newBoard := Board{grid, player, selectedCube}
return newBoard
} | func (*Devm_LpuBoards_LpuBoard) Descriptor() ([]byte, []int) {
return file_huaweiV8R12_devm_proto_rawDescGZIP(), []int{0, 6, 0}
} | func NewBoard(w, h int) *Board {
b := EmptyBoard(w, h)
// Just line the ends with robots
for i := 0; i < h; i++ {
la, lb := Loc{0, i}, Loc{w - 1, i}
ca, cb := b.cellIndex(la), b.cellIndex(lb)
b.cells[ca] = &Robot{
ID: b.newID(),
Health: InitialHealth,
Faction: P1Faction,
}
b.cells[cb] = &Ro... | func NewBoard(width, height int, c1, c2, c3, c4 *math32.Color, alpha float32) *Texture2D {
// Generates texture data
data := make([]float32, width*height*4*4)
colorData := func(sx, sy int, c *math32.Color) {
for y := sy; y < sy+height; y++ {
for x := sx; x < sx+width; x++ {
pos := (x + y*2*width) * 4
d... | func (d *Data) GetBoardName() string {
return d.boardName
} | func (i Monitor) GetDetails() string {
return fmt.Sprintf("Monitor Details\nResolution %v\nRefresh Rate %v", i.Resolution, i.RefreshRate)
} | func (game *Game) StringBoard() (string1, string2, string3, string4, string5, string6 string) {
output := make([]string, 6)
for i := 0; i < BoardHeight; i++ {
for j := 0; j < BoardWidth; j++ {
output[i] += ("| ")
if game.GameBoard[i][j].Active == false {
output[i] += ("__")
} else {
output[i] += ga... | func (b *Board) String() string {
var buffer bytes.Buffer
for i, b := range b.cells {
if (i+1)%9 == 0 {
buffer.WriteString(fmt.Sprintf("%d\n", b))
continue
}
buffer.WriteString(fmt.Sprintf("%d ", b))
}
return strings.TrimSpace(buffer.String())
} | func (*Devm_MpuBoards_MpuBoard) Descriptor() ([]byte, []int) {
return file_huaweiV8R12_devm_proto_rawDescGZIP(), []int{0, 5, 0}
} | func (b *Board) DrawBoard(renderer *sdl.Renderer) {
filledRectColor(renderer, b.x, b.y, 700, 550, sdl.Color{0, 0, 255, 255})
for row := range b.grid {
for _, counter := range b.grid[row] {
if counter.colour == "red" {
gfx.FilledCircleColor(renderer, counter.x, counter.y, counter.radius, sdl.Color{255, 0, 0, ... | func NewBoard(g Grid) Board {
rowMap := make(map[uint8]Dim, 9)
colMap := make(map[uint8]Dim, 9)
var i uint8
for i = 0; i < 9; i++ {
rowMap[i] = getRow(i)
colMap[i] = getColumn(i)
}
return Board{
rowIdx: rowMap,
colIdx: colMap,
cells: g,
}
} | func (board *Board) DrawBoard() {
for i := 0; i < board.width; i++ {
for j := 0; j < board.height; j++ {
if board.colors[i][j] != colorBlank {
view.DrawBlock(i, j, board.colors[i][j], board.rotation[i][j])
}
}
}
} | func (*BoardPlatform) Descriptor() ([]byte, []int) {
return file_cc_arduino_cli_commands_v1_board_proto_rawDescGZIP(), []int{6}
} | func ChessBoard(width, height int, symbol rune) (board string, err error) {
if err := validate(width, height); err != nil {
return "", err
}
for i := 0; i < height; i++ {
for j := 0; j < width; j++ {
// Detection "white" or "black" field of the chess board
if (i+j)%2 == 0 {
board += string(symbol)
}... | func (*Devm_Clockboards_Clockboard) Descriptor() ([]byte, []int) {
return file_huaweiV8R12_devm_proto_rawDescGZIP(), []int{0, 17, 0}
} | func (S *Board) DrawBoard() {
// set the name of the output png
var filename string = "board.png"
// create a new canvas
c := nCreateNewCanvas(S.size, S.size)
// for each row
for i := 0; i < S.size; i++ {
// for each column
for j := 0; j < S.size; j++ {
// set the colors for squares with different numbers... | [
"0.62864447",
"0.6065344",
"0.60006106",
"0.58561224",
"0.58390796",
"0.58044344",
"0.5763337",
"0.57586044",
"0.5751973",
"0.5700612",
"0.5691844",
"0.5686117",
"0.5682609",
"0.5682392",
"0.5680319",
"0.5673327",
"0.56470126",
"0.56463915",
"0.55986243",
"0.55600613",
"0.555... |
UploadCoverImage uploads a new cover image for an existing board. | func (s *BoardService) UploadCoverImage(boardID string, coverImage io.Reader) (*BoardUploadCoverImageResponse, *http.Response, error) {
body, contentType, err := mime.CreateMultipartMIMEAttachment(coverImage)
if err != nil {
return nil, nil, err
}
encodedResponse := make([]map[string]interface{}, 0)
decodedResp... | func UpdateCoverAPI(w http.ResponseWriter, r *http.Request) {
file, handler, err := r.FormFile("cover")
var extension = tools.GetExtension(handler.Filename)
var id = strconv.Itoa(int(middlew.IDUsuario))
var archivo string = "uploads/covers/" + id + "-" + middlew.Username + "." + extension
f, err := os.OpenFile... | func (sn *SlackNotifier) uploadImage(ctx context.Context, image ngmodels.Image, channel, comment, thread_ts string) error {
sn.log.Debug("Uploadimg image", "image", image.Token)
headers, data, err := sn.createImageMultipart(image, channel, comment, thread_ts)
if err != nil {
return fmt.Errorf("failed to create mul... | func (c *CouncillorsController) UploadProfilePic(ctx *app.UploadProfilePicCouncillorsContext) error {
var (
actor = ctx.Value("actor").(domain.Actor)
cRepo = domain.NewCouncillorRepo(config.Conf, actor, domain.AuthorisationService{})
)
uploaded, f, err := ctx.FormFile("file")
if err != nil {
return errors.Wra... | func (o *PutV1NuncConnectionsNuncConnectionIDParams) SetCoverImage(coverImage runtime.NamedReadCloser) {
o.CoverImage = coverImage
} | func UploadClubPhoto(db *gorm.DB, _ *redis.Client, _ http.ResponseWriter, r *http.Request, s *status.Status) (int, error) {
maxMem := int64(10 << 20)
clubID := getVar(r, model.ClubIDVar)
club := model.NewClub()
user := model.NewUser()
claims := GetTokenClaims(ExtractToken(r))
username := fmt.Sprintf("%v", claims[... | func UploadImageFile(part *multipart.Part) {
mediatype, _, _ := mime.ParseMediaType(part.Header.Get("Content-Type"))
log.Debugf("params %s", mediatype)
log.Debug("fileName : " + part.FileName())
inbuf, err := ioutil.ReadAll(part)
if err != nil {
log.CheckErrorWithMessage(err, "Image read failed.")
}
// Image ... | func (user *User) SetCover(cover *imageserver.MetaImage) error {
var lastError error
// Save the different image formats and sizes
for _, output := range coverImageOutputs {
err := output.Save(cover, user.ID)
if err != nil {
lastError = err
}
}
user.Cover.Extension = ".jpg"
user.Cover.LastModified = t... | func UploadImage(w http.ResponseWriter, r *http.Request) {
name, err := FileUpload(r)
if err != nil {
responses.ERROR(w, http.StatusNoContent, err)
return
}
user := models.User{}
db, err := database.Connect()
if err != nil {
responses.ERROR(w, http.StatusInternalServerError, err)
return
}
userID, _, er... | func (c CDNService) UploadImage(name string, data io.Reader) (string, error) {
now := time.Now()
fileName := fmt.Sprintf("%s_%d", name, now.UnixNano())
_, err := c.service.UploadStaticImage(fileName, data, "")
if err != nil {
return "", err
}
return c.service.Url(fileName, cloudinary.ImageType), nil
} | func (c *ImageCache) UploadImage(ID string, body io.Reader) error {
c.lock.Lock()
img, ok := c.images[ID]
if !ok {
c.lock.Unlock()
return image.ErrNoImage
}
if img.State == Saving {
c.lock.Unlock()
return image.ErrImageSaving
}
img.State = Saving
c.lock.Unlock()
if c.rawDs != nil {
_, err := c.r... | func (s *Service) Upload(ctx context.Context, accountID int64, mimetype string, imageData []byte) (string, error) {
return s.repo.Upload(ctx, &imagedata.Model{
AccountID: accountID,
MimeType: mimetype,
ImageData: imageData,
})
} | func (sm *SysModel) PerformImageUpload(bundleType string) error {
bkCtx, cancelFunc := context.WithTimeout(context.Background(), 15*time.Minute)
defer cancelFunc()
ctx, err := sm.VeniceLoggedInCtx(bkCtx)
if err != nil {
return err
}
for i := 0; i < 3; i++ {
_, err = sm.UploadBundle(ctx, bundleType)
if err ... | func (c Controller) Upload(
mydb models.MyDb,
oldImage_id int,
fileName string,
fileBytes []byte,
folder_id int,
userId int) (int, error) {
// 先upload file
// -------------- upload original file
tempFile, err := ioutil.TempFile("uploads", "pic_*.png")
if err != nil {
fmt.Println(err)
}
defer tempFile.Cl... | func (c *ConnectorManager) PostImage(
channelName string,
storyText string,
imageURL string,
icon messages.Icon,
asUser bool,
) {
for _, connector := range c.connectors {
connector.PostImage(channelName, storyText, imageURL, icon, asUser)
}
} | func UploadImage(basePath string, data []byte, ct string, tag ...string) (path string, err error) {
// upload with extension
fm, err := db.GetFormat(ct)
if err != nil {
logger.Error(err)
return
}
if fm == db.Formats[db.Jpeg] {
fm = "jpg"
}
if len(tag) > 0 {
path = basePath + "." + fm + tag[0]
} else ... | func submitImage(img *database.Image, u *database.User) {
i := registry.Image{Name: img.Name}
if img.IsPrivate {
if u == nil {
// If it's a private image but we don't have a user, just ignore this submission request
log.Infof("Ignoring anonymous request to submit private image")
return
}
user, password... | func uploadProfileImage(ctx context.Context, r io.Reader) (string, error) {
buf := &bytes.Buffer{}
err := image.JPEG(buf, r, 500, 500, 90, true)
if err != nil {
return "", err
}
filename := file.GenerateFilename() + ".jpg"
downloadURL, err := file.Store(ctx, buf, filename, false)
if err != nil {
return "", ... | func (op Operations) UploadImage(uuid, filepath string) error {
ctx := context.Background()
path := fmt.Sprintf("/images/%s/file", uuid)
file, err := os.Open(filepath)
if err != nil {
return fmt.Errorf("error: cannot open file: %s", err)
}
defer file.Close()
req, err := op.client.NewUploadRequest(http.Metho... | func UploadImage(loca string, id int, fileHeader *multipart.FileHeader) (newPath string, err error) {
file, err := fileHeader.Open()
defer file.Close()
if err == nil {
data, err := ioutil.ReadAll(file)
if err == nil {
//Show uploaded file in browser: fmt.Fprintln(w, string(data))
filetype := http.DetectC... | func (m *Medium) UploadImage(o UploadOptions) (*Image, error) {
o.fieldName = "image"
r := clientRequest{
method: "POST",
path: fmt.Sprintf("/v1/images"),
format: formatFile,
data: o,
}
i := &Image{}
err := m.request(r, i)
return i, err
} | func (r *Repository) Upload(ctx context.Context, i *imagedata.Model) (string, error) {
result, err := r.db.ExecContext(ctx, "INSERT INTO imagedata (`AccountID`, `mimetype`) VALUES (?, ?)", i.AccountID, i.MimeType)
if err != nil {
return "", err
}
id, err := result.LastInsertId()
if err != nil {
return "", err... | func (fs *FileService) UploadImage(ctx context.Context, selection string, f graphql.NamedReader) (*Photo, error) {
uploadErr := errFactory("upload image error")
query := fmt.Sprintf(uploadImageQuery, selection)
resp, err := fs.client.graphqlClient.SingleUpload(ctx, query, "uploadImage", f)
if err != nil {
return ... | func (user *User) SetCoverBytes(data []byte) error {
// Decode
img, format, err := image.Decode(bytes.NewReader(data))
if err != nil {
return err
}
return user.SetCover(&imageserver.MetaImage{
Image: img,
Format: format,
Data: data,
})
} | func uploadPicture(c *gin.Context) {
// Source
file, err := c.FormFile("file")
if err != nil {
c.String(http.StatusBadRequest, fmt.Sprintf("get form err: %s", err.Error()))
return
}
filename := filepath.Base(file.Filename)
if err := c.SaveUploadedFile(file, "media/images/"+filename); err != nil {
c.String(... | func UploadImage(ctx context.Context, name, data string) (string, error) {
imageBytes, err := base64.StdEncoding.DecodeString(data)
cfg, fmt, err := image.DecodeConfig(bytes.NewReader(imageBytes))
if err != nil {
return "", session.ServerError(ctx, err)
}
if cfg.Width < 600 || cfg.Height < 300 {
return "", ses... | func UploadImage(filePath string, libraryRef string, libraryURL string, authToken string, description string) error {
if !IsLibraryPushRef(libraryRef) {
return fmt.Errorf("Not a valid library reference: %s", libraryRef)
}
imageHash, err := ImageHash(filePath)
if err != nil {
return err
}
sylog.Debugf("Image... | func (h *handlers) UploadImage(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "this is hit")
uploadRequest := newRequest(r).
BindURLParams().
BindQueryParams()
fmt.Fprintf(w, "%v", uploadRequest)
} | func UploadImage(client *gophercloud.ServiceClient, id string, opts UploadImageOptsBuilder) (r UploadImageResult) {
b, err := opts.ToVolumeUploadImageMap()
if err != nil {
r.Err = err
return
}
resp, err := client.Post(actionURL(client, id), b, &r.Body, &gophercloud.RequestOpts{
OkCodes: []int{202},
})
_, r.... | func (o *PutV1NuncConnectionsNuncConnectionIDParams) WithCoverImage(coverImage runtime.NamedReadCloser) *PutV1NuncConnectionsNuncConnectionIDParams {
o.SetCoverImage(coverImage)
return o
} | func (c *Controller) UploadPhoto(w http.ResponseWriter, r *http.Request) {
err := r.ParseMultipartForm(32 << 20)
if err != nil {
SendError(w, err.Error(), http.StatusBadRequest)
return
}
file, multipartFileHeader, err := r.FormFile("photo")
if err != nil {
SendError(w, err.Error(), http.StatusBadRequest)
... | func (a *Article) SetCoverImage(url, caption string) {
if url != "" {
a.Body.Article.Header.Figure = append(a.Body.Article.Header.Figure, &Figure{
Img: &Img{Src: url},
Figcaption: caption,
})
}
} | func uploadResumeImage(w http.ResponseWriter, r *http.Request) {
returnCode := 0
if uID, err := readSession("userID", w, r); err == nil && uID != nil {
categoryStr := vestigo.Param(r, "category")
resumeID := vestigo.Param(r, "resumeID")
userID := uID.(string)
var fileName string
categoryInt, err := strcon... | func (p *Posts) ImageUpload(res http.ResponseWriter, req *http.Request) {
post, err := p.postByID(res, req)
if err != nil {
// implemented by postByYearAndTitle
return
}
user := context.User(req.Context())
if user.IsAdmin != true {
http.Error(res, "You do not have permission to edit this post", http.StatusFo... | func (imageCreator EcsImageCreator) PushImage(dockerInfo *DockerInfo) (chan (string), error) {
//check if it exists on ecs, if not create it first
imageName := dockerInfo.GetImageName()
exists, err := imageCreator.imageExists(imageName)
if err != nil {
return nil, err
}
if !exists {
LogInfo.Printf("Image... | func (uc *uploadUsecase) Save(c context.Context, m *models.ImageFile) error {
_, cancel := context.WithTimeout(c, uc.contextTimeout)
defer cancel()
err := ioutil.WriteFile(m.Path, m.Data, 0666)
if err != nil {
return err
}
return nil
} | func (c Connection) Upload(src, dst string, opts ...exec.Option) error {
if !c.IsConnected() {
return &NotConnectedError{&c}
}
return c.client.Upload(src, dst, opts...)
} | func UploadImageForHome(c *gin.Context) {
_, header, err := c.Request.FormFile("file")
id := c.Param("id")
if err != nil {
c.JSON(200, gin.H{"error": err.Error()})
return
}
params, err := lib.UploadImageToS3(header, id)
if err != nil {
c.JSON(200, gin.H{"error": err.Error()})
return
}
path := lib.Cr... | func (c *Client) UploadImage(ctx context.Context, r io.ReadSeeker, path string, tags []string, description string, callback UploadCallback) error {
entityName, collectionName, containerName, parsedTags := ParseLibraryPath(path)
if len(parsedTags) != 0 {
return fmt.Errorf("malformed image path: %s", path)
}
imag... | func uploadFile(req JobRequest, image_to_upload entities.Image, statuschannel chan entities.StatusMsg) {
statuschannel <- entities.StatusMsg{100, "Uploading", nil}
if err := sendToUploader(
image_to_upload.Reader(),
mimetype(req.Uploaded_filename),
req.Uploaded_filename,
); err != nil {
statuschannel <- enti... | func UpImagePublicacion(w http.ResponseWriter, r *http.Request) {
file, handler, err := r.FormFile("foto")
var ext = strings.Split(handler.Filename, ".")[1]
var file1 string = "uploads/publicaciones/" + IDUsuario + "." + ext
f, err := os.OpenFile(file1, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
http.Error(w... | func (idb *InDB) Upload(c *gin.Context) {
var (
Asset models.UploadAsset
userInfo UserInfo
)
userData := c.GetHeader("User-Info")
if userData == "" {
c.JSON(http.StatusBadRequest, _u.Message(false, "User not found", nil, nil))
return
}
err := json.Unmarshal([]byte(userData), &userInfo)
if err != ni... | func RegisterImage(ctx context.Context, conv Conversation) {
image := conv.String("image")
tag := conv.String("tag")
env := conv.String("env")
if env == "" {
env = "production"
}
jb, found := jobBoards[env]
if !found {
ReplyTo(conv).ErrorText("No job board is configured for the %s environment.", env).Send()... | func (it *DefaultApi) AccountUpdateProfileBackgroundImagePost(_client swagger.FetchClient, _request *DefaultApiAccountUpdateProfileBackgroundImagePostRequest, result *Settings) error {
if !_client.NewValidator(_request.File, _request.File == nil).Required(true).Valid(_client) {
return errors.New(0, "Missing the requ... | func (c *Client) PutImage(ctx context.Context, userAuthToken, serviceAuthToken, collectionID, imageID string, data Image) (m Image, err error) {
payload, err := json.Marshal(data)
if err != nil {
return
}
uri := fmt.Sprintf("%s/images/%s", c.hcCli.URL, imageID)
clientlog.Do(ctx, "updating instance import_tasks... | func (controller *UploadController) Upload(name string, size uint64, hash []byte, laddr string) error {
conn, err := connectionmngr.ConnectToCenter()
if err != nil {
return err
}
defer conn.Close()
fyerCenterClient := pb_center.NewFyerCenterClient(conn.ClientConn)
_, err = fyerCenterClient.Register(context.TOD... | func (a *CPCHandler) CreateCity(c echo.Context) error {
c.Request().Header.Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization")
c.Response().Header().Set("Access-Control-Allow-Headers", "Accept, Content-Type, Content-Length, Accept-Encoding, X-CSRF-... | func (c *Client) PostImage(ctx context.Context, userAuthToken, serviceAuthToken, collectionID string, data NewImage) (m Image, err error) {
payload, err := json.Marshal(data)
if err != nil {
return
}
uri := fmt.Sprintf("%s/images", c.hcCli.URL)
clientlog.Do(ctx, "posting new image", service, uri)
resp, err :... | func (o *OpenStack) CreateImage(ctx *lepton.Context, imagePath string) error {
c := ctx.Config()
imgName := c.CloudConfig.ImageName
imgName = strings.ReplaceAll(imgName, "-image", "")
log.Info("creating image:\t" + imgName)
imagesClient, err := o.getImagesClient()
if err != nil {
log.Error(err)
}
image, e... | func (c *Client) Upload(_, name string, src io.Reader) error {
repo, tag, err := decomposeDockerTag(name)
if err != nil {
return fmt.Errorf("tag path: %s. Err was %s", name, err)
}
buf := new(bytes.Buffer)
if _, err := buf.ReadFrom(src); err != nil {
return err
}
imageID := buf.String()
gormTag := Tag{
... | func (c *Client) CreateImage(request *CreateImageRequest) (response *CreateImageResponse, err error) {
if request == nil {
request = NewCreateImageRequest()
}
response = NewCreateImageResponse()
err = c.Send(request, response)
return
} | func (drv Driver) Upload(dst string, src ...string) error {
return drv.RsyncClient.Copy(dst, src...)
} | func (drv Driver) Upload(dst string, src ...string) error {
return drv.RsyncClient.Copy(dst, src...)
} | func Upload(cfg map[string]interface{}) error {
return mg.Upload(cfg)
} | func UploadAnImageFromAurlToMicrosCdn() {
imageService := image.NewImageService(os.Getenv("MICRO_API_TOKEN"))
rsp, err := imageService.Upload(&image.UploadRequest{
Name: "cat.jpeg",
Url: "somewebsite.com/cat.png",
})
fmt.Println(rsp, err)
} | func UploadPicture(c *gin.Context) (int, interface{}) {
file, err := c.FormFile("picture")
if err != nil {
return utils.MakeErrJSON(400, 40025,
locales.I18n.T(c.GetString("lang"), "file.select_picture"),
)
}
fileExt := map[string]string{
"image/png": ".png",
"image/gif": ".gif",
"image/jpeg": ".jpg",... | func (c *Connection) UPLOAD() {
c.Upload(nil)
} | func (jb *JobBoard) RegisterImage(ctx context.Context, image, tag string) error {
v := url.Values{}
v.Set("infra", "jupiterbrain")
v.Set("name", image)
v.Set("tags", "os:osx,osx_image:"+tag)
body := strings.NewReader(v.Encode())
req, err := jb.newRequest("POST", "/images", body)
if err != nil {
return err
}
... | func (cli *OSSClient) Upload(filePath string) error {
bucket, err := cli.ossClient.Bucket(bucketName)
if err != nil {
return errors.New("there is not bucket named: " + bucketName)
}
err = bucket.PutObjectFromFile(bucketName, filePath)
if err != nil {
return err
}
return nil
} | func Upload(cfg *ReleaseConfig, _ *github.GitHub, outputDir string) error {
uploadBase := filepath.Join(outputDir, cfg.Org, cfg.Repo)
tags := cfg.Tags
for _, tag := range tags {
srcDir := filepath.Join(uploadBase, tag)
gcsPath := filepath.Join(cfg.GCSBucket, cfg.ReleaseDir, tag)
gcs := object.NewGCS()
if e... | func (fs *FireStore) Upload(ctx context.Context, user *domain.User,
attrs *domain.ImgAttrs, file string) error {
doc := make(map[string]interface{})
doc["obj_type"] = attrs.ObjType
doc["material"] = attrs.Material // Silk / Cotton
doc["speciality"] = attrs.Speciality // Kancheepuram / Banaras
do... | func (c *Client) UploadImage(ctx context.Context, p *UploadImagePayload) (res *Image, err error) {
var ires interface{}
ires, err = c.UploadImageEndpoint(ctx, p)
if err != nil {
return
}
return ires.(*Image), nil
} | func (w *Writer) importAndAddCover() {
// no need to add cover if no cover is set
if w.cfg.General.Cover == "" {
return
}
internalFilePath, err := w.Epub.AddImage(w.cfg.General.Cover, "cover"+filepath.Ext(w.cfg.General.Cover))
raven.CheckError(err)
w.Epub.SetCover(internalFilePath, w.cfg.Assets.CSS.InternalPa... | func (c *giteaClient) Upload(
ctx *context.Context,
releaseID string,
artifact *artifact.Artifact,
file *os.File,
) error {
giteaReleaseID, err := strconv.ParseInt(releaseID, 10, 64)
if err != nil {
return err
}
releaseConfig := ctx.Config.Release
owner := releaseConfig.Gitea.Owner
repoName := releaseConfig... | func upload(minioClient *minio.Client, bucketName, objectName, contextType, filePath string) {
location := "us-east-1"
if exists, _ := minioClient.BucketExists(bucketName); exists {
log.Printf("we already own %s\n", bucketName)
} else {
if err := minioClient.MakeBucket(bucketName, location); err != nil {
che... | func (sn *SlackNotifier) createImageMultipart(image ngmodels.Image, channel, comment, thread_ts string) (http.Header, []byte, error) {
buf := bytes.Buffer{}
w := multipart.NewWriter(&buf)
defer func() {
if err := w.Close(); err != nil {
sn.log.Error("Failed to close multipart writer", "err", err)
}
}()
f, ... | func UploadProfilePicCouncillorsUnauthorized(t *testing.T, ctx context.Context, service *goa.Service, ctrl app.CouncillorsController, id string) http.ResponseWriter {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interface{}) { resp = r }
)
if se... | func UploadProfilePicCouncillorsOK(t *testing.T, ctx context.Context, service *goa.Service, ctrl app.CouncillorsController, id string) (http.ResponseWriter, *app.GoaLocalCouncillor) {
// Setup service
var (
logBuf bytes.Buffer
resp interface{}
respSetter goatest.ResponseSetterFunc = func(r interface{}) { res... | func UpAvatar(w http.ResponseWriter, r *http.Request) {
file, handler, err := r.FormFile("avatar")
var ext = strings.Split(handler.Filename, ".")[1]
var file1 string = "uploads/avatars/" + IDUsuario + "." + ext
f, err := os.OpenFile(file1, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
http.Error(w, "Error al ac... | func (c BmSampleCoverResource) Create(obj interface{}, r api2go.Request) (api2go.Responder, error) {
choc, ok := obj.(BmModel.SampleCover)
if !ok {
return &Response{}, api2go.NewHTTPError(errors.New("Invalid instance given"), "Invalid instance given", http.StatusBadRequest)
}
id := c.BmSampleCoverStorage.Insert(... | func (c *Client) ImportImage(request *ImportImageRequest) (response *ImportImageResponse, err error) {
if request == nil {
request = NewImportImageRequest()
}
response = NewImportImageResponse()
err = c.Send(request, response)
return
} | func (s *S3) UploadProfilePicture(file multipart.File, header *multipart.FileHeader, studentID string) (string, error) {
size := header.Size
buffer := make([]byte, size)
file.Read(buffer)
fileBytes := bytes.NewReader(buffer)
fileType := http.DetectContentType(buffer)
path := s.path + studentID + filepath.Ext(head... | func (b *Imagizer) BuildImage(region, builderType string, volumeId int) (*linodego.Image, error) {
timestamp := time.Now().Unix()
log.Printf("Getting volume...\n")
volume, err := b.client.GetVolume(context.Background(), volumeId)
if err != nil {
return nil, fmt.Errorf("failed to retrieve volume: %v", err)
}
i... | func uploadController(ctx echo.Context) error {
clowdee := ctx.Get("clowdee").(*model.Clowdee)
// bind uploaded data into array of `fileOnClient` struct
files := make([]*fileOnClient, 0)
if err := ctx.Bind(&files); err != nil {
logger.File().Infof("Error binding client's uploaded file, %s", err)
return err
}
... | func (w *WithProgress) WriteImage(reference regname.Reference, image regv1.Image, _ chan regv1.Update) error {
uploadProgress := make(chan regv1.Update)
w.logger.Start(context.Background(), uploadProgress)
defer w.logger.End()
return w.delegate.WriteImage(reference, image, uploadProgress)
} | func (s *API) CreateImage(req *CreateImageRequest, opts ...scw.RequestOption) (*CreateImageResponse, error) {
var err error
defaultProject, exist := s.client.GetDefaultProjectID()
if exist && req.Organization == nil && req.Project == nil {
req.Project = &defaultProject
}
defaultOrganization, exist := s.client.... | func (r *Repository) UploadImg(img image.Image, Name string) (string, error) {
fileName := strings.Split(Name, "/")[1]
filePath := filepath.Join("/tmp", fileName+".png")
file, err := os.Create(filePath)
if err != nil {
return "", errors.Wrap(err, "failed to create file")
}
defer file.Close()
err = png.Encode(... | func Upload(cfg map[string]interface{}) error {
return cfgMgr.UpdateConfig(cfg)
} | func Upload(b *library.Build, c *vela.Client, e error, l *logrus.Entry, r *library.Repo) {
// handle the build based off the status provided
switch b.GetStatus() {
// build is in a canceled state
case constants.StatusCanceled:
fallthrough
// build is in a error state
case constants.StatusError:
fallthrough
/... | func Upload(w http.ResponseWriter, r *http.Request) {
file, header, err := r.FormFile("image")
if err != nil {
http.Error(w, "Invalid file", http.StatusBadRequest)
}
defer file.Close()
ext := filepath.Ext(header.Filename)[1:]
outFile, err := tempFile("", ext)
if err != nil {
http.Error(w, "New File can not ... | func (c *Client) Upload(src []byte, dest string) error {
_, err := c.sendRequest("PUT", dest, src)
return err
} | func Upload(clusterName, group, ext string, b []byte) (string, error) {
return DefaultClient.Upload(clusterName, group, ext, b)
} | func (u *OSSUploader) Upload(objectKey, filePath string) error {
return u.bucket.PutObjectFromFile(objectKey, filePath)
} | func (p *Platform) UploadRandomImage(channel *model.Channel, rm RandomMessage) (res *model.FileUploadResponse, err error) {
name, data, ok := rm.Media()
if !ok {
return nil, errors.New("Could not load random image for MultipartImage")
}
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := wr... | func (d *Deployments) CreateImage(ctx context.Context,
multipartUploadMsg *model.MultipartUploadMsg) (string, error) {
return d.handleArtifact(ctx, multipartUploadMsg, false)
} | func SaveImage(imageUrl string) {
filePath := "/Users/batman/Downloads/image/" + path.Base(imageUrl)
f, _ := os.Create(filePath)
resp, _ := http.Get(imageUrl)
defer f.Close()
defer resp.Body.Close()
reader := bufio.NewReaderSize(resp.Body, 32*1024)
writer := bufio.NewWriter(f)
_, _ = io.Copy(writer, reader)
fm... | func (a Activity) Upload(filename string) error {
ctx := context.Background()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(config.MongoURI))
if err != nil {
return err
}
defer client.Disconnect(ctx)
_, err = client.Database("club").Collection("activities").UpdateByID(ctx, a.ID, bson.D{bson.E{Key... | func (u *Uploader) Upload(source string, destination string, contType string) error {
reader, err := os.Open(source)
if err != nil {
return err
}
defer reader.Close()
timeout := 4 * time.Minute
ctx := context.Background()
var cancelFn func()
if timeout > 0 {
ctx, cancelFn = context.WithTimeout(ctx, timeou... | func SaveImage(img Image, t time.Time, saveDirectory string, jpegQuality int, name string, title string, percentage string) (savePath string) {
savePath = GetImageFilename(t, saveDirectory, name, title, percentage)
jpgParams := []int{gocv.IMWriteJpegQuality, jpegQuality}
if img.SharedMat != nil {
img.SharedMat.Gua... | func (d *Dao) SetNewCoverCache(c context.Context, mid, fid int64, covers []*model.Cover) (err error) {
key := coversKey(mid, fid)
conn := d.redisPool.Get(c)
defer conn.Close()
for _, cover := range covers {
var bs []byte
if bs, err = json.Marshal(cover); err != nil {
log.Error("json.Marshal(%v) err(%v)", cov... | func (_m *Asset) Upload(_a0 int64, _a1 repository.Interface, _a2 interfaces.GitHub, _a3 *sync.WaitGroup, _a4 chan string, _a5 chan error) {
_m.Called(_a0, _a1, _a2, _a3, _a4, _a5)
} | func (o *deployHandler) ApplyImage(img v1alpha2.Component) error {
return image.BuildPushSpecificImage(o.ctx, o.fs, img, true)
} | func (c *OpmlController) Upload(ctx *app.UploadOpmlContext) error {
// OpmlController_Upload: start_implement
// Put your logic here
return nil
// OpmlController_Upload: end_implement
} | func UploadAvatar(w http.ResponseWriter, r *http.Request) {
file, handler, err := r.FormFile("avatar")
var extension = strings.Split(handler.Filename, ".")[1]
var archivo string = "uploads/avatars/" + IDUsuario + "." + extension
f, err := os.OpenFile(archivo, os.O_RDONLY|os.O_CREATE, 0666)
if err != nil {
http.... | func (c *Client4) UploadBrandImage(data []byte) (*Response, error) {
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
part, err := writer.CreateFormFile("image", "brand.png")
if err != nil {
return nil, NewAppError("UploadBrandImage", "model.client.set_profile_user.no_file.app_error", nil, "", http.St... | func (s *GRPCWorker) UploadImage(stream network.ShotisService_UploadImageServer) error {
var header *network.FileHeader
var buf bytes.Buffer
for {
message, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
stream.SendAndClose(&network.UploadImageResponse{
Status: network.Status_Fa... | func CreateImageEndPoint(w http.ResponseWriter, r *http.Request) {
fmt.Println("hit")
defer r.Body.Close()
var image Image
if err := json.NewDecoder(r.Body).Decode(&image); err != nil {
log.Fatal(err)
respondWithError(w, http.StatusBadRequest, "Invalid request payload")
return
}
image.ID = bso... | func (graph *Graph) PushImage(stdout io.Writer, imgOrig *Image, authConfig *auth.AuthConfig) error {
client := &http.Client{}
// FIXME: Factorize the code
// FIXME: Do the puts in goroutines
if err := imgOrig.WalkHistory(func(img *Image) error {
jsonRaw, err := ioutil.ReadFile(path.Join(graph.Root, img.Id, "jso... | func (ds *gitEndpoint) Upload(destFolder, endpointUsername, endpointPassword, endpointURL string) (err error) {
fmt.Println("Uploading Site...")
dest := destFolder + "_upload"
err = fs.CreateFolderIfNotExist(dest)
if err != nil {
return err
}
err = fs.ClearFolder(dest)
if err != nil {
return err
}
cmdName... | func (it *DefaultApi) AccountUpdateProfileImagePost(_client swagger.FetchClient, _request *DefaultApiAccountUpdateProfileImagePostRequest, result *Settings) error {
if !_client.NewValidator(_request.Image, _request.Image == nil).Required(true).Valid(_client) {
return errors.New(0, "Missing the required parameter 'Im... | func CreaeteScreenshot(w http.ResponseWriter, r *http.Request) {
// Validate key
r.ParseMultipartForm(0)
key := r.FormValue("key")
if key != config.APIKey {
SendJSON(w, Response{
Status: 401,
State: "fail",
Result: "error: unauthorized key",
})
return
}
// Get filename and the screenshot itself
... | [
"0.5690978",
"0.5593112",
"0.5521259",
"0.5377795",
"0.53713155",
"0.5313939",
"0.5117988",
"0.5065991",
"0.50104195",
"0.5007211",
"0.4999661",
"0.4996211",
"0.49158025",
"0.48561",
"0.48518842",
"0.48405692",
"0.4824553",
"0.48045886",
"0.48018578",
"0.47900888",
"0.4776066... |
RunVolumeQuery queries BigQuery for the volume of assets over the specified corridor and returns the results | func RunVolumeQuery(asset Asset, volumeFrom bool, startUnixTimestamp, endUnixTimestamp, aggregateBy string, client *bigquery.Client) ([]VolumeResult, error) {
query := createVolumeQuery(asset, volumeFrom, startUnixTimestamp, endUnixTimestamp, aggregateBy)
it, err := runQuery(query, client)
if err != nil {
return n... | func (volumeService Service) QueryVolumes(queryParameters *QueryParameters) ([]Response, error) {
volumesContainer := volumesResponse{}
err := volumeService.queryVolumes(false /*includeDetails*/, &volumesContainer, queryParameters)
if err != nil {
return nil, err
}
return volumesContainer.Volumes, nil
} | func (volumeService Service) QueryVolumesDetail(queryParameters *QueryParameters) ([]DetailResponse, error) {
volumesDetailContainer := volumesDetailResponse{}
err := volumeService.queryVolumes(true /*includeDetails*/, &volumesDetailContainer, queryParameters)
if err != nil {
return nil, err
}
return volumesDet... | func queryDB(client influxdb.Client, cmd string) (res []influxdb.Result, err error) {
q := influxdb.Query{
Command: cmd,
Database: AwsSpotPricesDBName,
}
if response, err := client.Query(q); err == nil {
if response.Error() != nil {
return res, response.Error()
}... | func RunVolumeGet(c *CmdConfig) error {
if len(c.Args) == 0 {
return doctl.NewMissingArgsErr(c.NS)
}
id := c.Args[0]
al := c.Volumes()
d, err := al.Get(id)
if err != nil {
return err
}
item := &volume{volumes: []do.Volume{*d}}
return c.Display(item)
} | func RunVolumeGet(c *CmdConfig) error {
if len(c.Args) == 0 {
return doctl.NewMissingArgsErr(c.NS)
}
id := c.Args[0]
al := c.Volumes()
d, err := al.Get(id)
if err != nil {
return err
}
item := &displayers.Volume{Volumes: []do.Volume{*d}}
return c.Display(item)
} | func queryScalar(runner runner, builder dat.Builder, destinations ...interface{}) error {
fullSQL, args, err := builder.Interpolate()
if err != nil {
return err
}
// Start the timer:
startTime := time.Now()
defer func() { dat.Events.TimingKv("QueryScalar", time.Since(startTime).Nanoseconds(), M{"sql": fullSQL}... | func VolumeAnalysis(r *mmap.ReaderAt) (stats volume.VolumeStats) {
np := runtime.GOMAXPROCS(-1)
results := make([]*result.Result, np)
for i, _ := range results {
results[i] = result.NewResult()
start := 0
end := r.Len()
go runSum(r, i, start, end, np, results[i] /*, progress*/)
}
stats.Min = math.MaxFloat... | func RunVolumeList(c *CmdConfig) error {
al := c.Volumes()
region, err := c.Doit.GetString(c.NS, doctl.ArgRegionSlug)
if err != nil {
return nil
}
matches := make([]glob.Glob, 0, len(c.Args))
for _, globStr := range c.Args {
g, err := glob.Compile(globStr)
if err != nil {
return fmt.Errorf("Unknown gl... | func RunQuery(ctx context.Context, logf logging.FormatLogger, promAPI v1.API, query string) (float64, error) {
logf("Running prometheus query: %s", query)
value, _, err := promAPI.Query(ctx, query, time.Now())
if err != nil {
return 0, err
}
return VectorValue(value)
} | func (c *AppConfig) RunQuery() (*QueryResult, error) {
environment, buildEnvironment, parameters, err := c.validate()
if err != nil {
return nil, err
}
// TODO: I don't belong here
c.ensureDockerSearch()
if c.AsList {
if c.AsSearch {
return nil, errors.New("--list and --search can't be used together")
}... | func runQuery(args []string) error {
var (
flagset = flag.NewFlagSet("query", flag.ExitOnError)
debug = flagset.Bool("debug", false, "debug logging")
apiAddr = flagset.String("api", defaultAPIAddr, "listen address for query API")
fileStore = flagset.String("filestore", defaultFileStore, "location of whe... | func RunVolumeList(c *CmdConfig) error {
al := c.Volumes()
d, err := al.List()
if err != nil {
return err
}
item := &volume{volumes: d}
return c.Display(item)
} | func (vm *VM) ExportAssetsQuery(cmd *cobra.Command, args []string) {
vm.Config.VM.EnableLogging()
a := client.NewAdapter(vm.Config, vm.Metrics)
uuid := vm.Config.VM.UUID
chunks := vm.Config.VM.Chunk
jqex := vm.Config.VM.JQex
if jqex == "" {
jqex = ".[]"
a.Config.VM.Log.Infof("query --jqex was not specified ... | func runQueryView(configuration android.Config, ctx *android.Context) {
codegenContext := bp2build.NewCodegenContext(configuration, *ctx, bp2build.QueryView)
absoluteQueryViewDir := shared.JoinPath(topDir, bazelQueryViewDir)
if err := createBazelQueryView(codegenContext, absoluteQueryViewDir); err != nil {
fmt.Fpr... | func ExecuteRichQuery(stub shim.ChaincodeStubInterface,args []string) peer.Response {
// Query JSON received as argument
qry:=args[0]
// Print the received query on the console
fmt.Printf("Query JSON=%s \n\n", qry)
// GetQueryResult
QryIterator, err := stub.GetQueryResult(qry)
// Return if there is an error
... | func (o IndexerClusterSpecVolumesQuobyteOutput) Volume() pulumi.StringOutput {
return o.ApplyT(func(v IndexerClusterSpecVolumesQuobyte) string { return v.Volume }).(pulumi.StringOutput)
} | func ExecuteQuery(params *app.HostsPayload, query string) gocb.QueryResults {
// Get connect to couchbase bucket.
bucket := GetCbBucket("")
// Execute
rows, err := bucket.ExecuteN1qlQuery(gocb.NewN1qlQuery(query), nil)
if err != nil {
zlog.Error().Err(err).Msg("Could not query in N1QL.")
}
return rows
} | func (m *Client) QueryRaw(ctx context.Context, req *gqV2.Request, resp interface{}) (err error) {
// run it and capture the response
return m.v2.Run(ctx, req, &resp)
} | func (suite *PouchRunSuite) TestRunWithVolumesFrom(c *check.C) {
volumeName := "volumesfrom-test-volume"
containerName1 := "volumesfrom-test-1"
containerName2 := "volumesfrom-test-2"
// create volume
command.PouchRun("volume", "create", "-n", volumeName).Assert(c, icmd.Success)
defer func() {
command.PouchRun(... | func (e *ArangoStore) RunQuery(ctx context.Context, query string, bindVars map[string]interface{}, document interface{}) ([]interface{}, error) {
log.Printf("input query = %s", query)
// Empty DocList
docList := []interface{}{}
cursor, err := e.connvars.db.Query(ctx, query, bindVars)
if err != nil {
cursor.Clos... | func (o SearchHeadClusterSpecVolumesQuobyteOutput) Volume() pulumi.StringOutput {
return o.ApplyT(func(v SearchHeadClusterSpecVolumesQuobyte) string { return v.Volume }).(pulumi.StringOutput)
} | func (t *MedicalApp) queryAsset(APIstub shim.ChaincodeStubInterface, args []string) peer.Response {
if len(args) != 1 {
return shim.Error("Incorrect number of arguments, Required 1")
}
fmt.Println(fmt.Sprintf("- start queryAsset: %s\n", args))
AssetAsBytes, _ := APIstub.GetState(args[0])
if AssetAsBytes... | func (m *Mongo) RawQuery(ctx context.Context, query string, args []interface{}) (int64, interface{}, error) {
return 0, "", errors.New("error raw querry operation cannot be performed on mongo")
} | func (v *volume) runInTemporaryContainer(ctx context.Context, cmd []string) ([]byte, error) {
// Create a container that mounts a volume and deletes its file. Run rm -rf on it.
cid, err := v.createContainer(ctx, cmd)
if err != nil {
return nil, err
}
defer func() {
err := v.client.ContainerRemove(ctx, cid, typ... | func (t *AssetChaincode) queryAssetsByOwner(stub shim.ChaincodeStubInterface, args []string) pb.Response {
// 0
// "bob"
if len(args) < 1 {
return shim.Error("Incorrect number of arguments. Expecting 1")
}
owner := strings.ToLower(args[0])
q... | func (repo *ArtifactRepository) VolumeOn(worker Worker) (Volume, bool, error) {
return nil, false, nil
} | func (db *BigTable) RawRangeQuery(kStart, kEnd storage.Key, keysOnly bool, out chan *storage.KeyValue, cancel <-chan struct{}) error {
if db == nil {
return fmt.Errorf("Can't call RawRangeQuery() on nil BigTable")
}
unvKeyBeg, verKeyBeg, err := storage.SplitKey(kStart)
if err != nil {
dvid.Errorf("Error in Raw... | func (o StandaloneSpecVolumesQuobyteOutput) Volume() pulumi.StringOutput {
return o.ApplyT(func(v StandaloneSpecVolumesQuobyte) string { return v.Volume }).(pulumi.StringOutput)
} | func (s *getArtifactSource) VolumeOn(worker worker.Worker) (worker.Volume, bool, error) {
return s.resourceInstance.FindOn(s.logger.Session("volume-on"), worker)
} | func (t *BlockChainTaskChainCode) queryCraetedVehicleByManufacturer(stub shim.ChaincodeStubInterface, args []string) pb.Response {
queryString := fmt.Sprintf("{\"selector\":{\"docType\":\"vehicles\",\"ownership\":\"Manufacturer\"}}")
queryResults, err := getQueryResultForQueryString(stub, queryString)
if err !=... | func (tldb *TradeLogDB) GetUserVolume(userAddress ethereum.Address, from, to time.Time, freq string) (map[uint64]common.UserVolume, error) {
var (
timeField string
logger = tldb.sugar.With("from", from, "to", to,
"userAddress", userAddress, "freq", freq, "func", caller.GetCurrentFunctionName())
)
switch st... | func (c *CmdVolumeOptions) RunVolumeInfo(cmd *cobra.Command) error {
volumeInfo := &VolumeInfo{}
// FetchVolumeInfo is called to get the volume controller's info such as
// controller's IP, status, iqn, replica IPs etc.
volumeInfo, err := NewVolumeInfo(mapiserver.GetURL()+VolumeAPIPath+c.volName, c.volName, c.names... | func RunQueryRange(ctx context.Context, logf logging.FormatLogger, promAPI v1.API, query string, r v1.Range) (float64, error) {
logf("Running prometheus query: %s", query)
value, _, err := promAPI.QueryRange(ctx, query, r)
if err != nil {
return 0, err
}
return VectorValue(value)
} | func (query *Query) RunQuery(client beat.Client) error {
events := []common.MapStr{}
wmiscriptObj, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
if err != nil {
logp.Err("Unable to create object: %v", err)
return err
}
defer wmiscriptObj.Release()
wmiqi, err := wmiscriptObj.QueryInterf... | func getVolumes(osp *OpenstackPlugin) component.Component {
rows := []component.TableRow{}
err := volumes.List(volumeClientHelper(osp), volumes.ListOpts{}).EachPage(
func(page pagination.Page) (bool, error) {
volumeList, err := volumes.ExtractVolumes(page)
if err != nil {
log.Printf("Broken at volume li... | func (self *BoltStatStorage) GetAssetVolume(fromTime uint64, toTime uint64, freq string, ethAssetAddr ethereum.Address) (common.StatTicks, error) {
result := common.StatTicks{}
assetAddr := common.AddrToString(ethAssetAddr)
err := self.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(assetAddr))
if b == n... | func (backend *InfluxBackend) Query(ctx context.Context, query *Query) (Results, error) {
fluxQuery, err := buildFluxQuery(backend.Bucket, query)
if err != nil {
return nil, err
}
queryAPI := backend.Client.QueryAPI(backend.Bucket)
results, err := queryAPI.Query(ctx, fluxQuery)
if err != nil {
return nil, e... | func (s *SmartContract) QueryAssets(ctx contractapi.TransactionContextInterface, queryString string) ([]*RandomBox, error) {
return getQueryResultForQueryString(ctx, queryString)
} | func VolumeByEquinoxLrn(db XODB, equinoxLrn int64) (*Volume, error) {
var err error
// sql query
const sqlstr = `SELECT ` +
`voluniquesys, volchrgoption, volfromto, volchargetype, volminsorpounds, voldiscountorvol, volvatrate, volthresholdrat1, volthresholdrat2, volthresholdrat3, volthresholdrat4, volthresholdrat... | func (volumeService Service) Volumes() (volume []Response, err error) {
return volumeService.QueryVolumes(nil)
} | func (c *Client) QueryVolumeChildren(
ctx context.Context, name string) (VolumeChildrenMap, error) {
return apiv2.ContainerChildrenMapAll(ctx, c.API, name)
} | func (c *BlobClient) Query() *BlobQuery {
return &BlobQuery{config: c.config}
} | func (t *ChaincodeType) Query(stub shim.ChaincodeStubInterface, function string, args []string) ([]byte, error) {
if function == "retrieveBlob" {
return t.retrieveBlob(stub, args)
}
return nil, errors.New("invalid query function name")
} | func (w *FabricSDKWrapper) Query(channelID string, userName string, chaincodeID string, ccFunctionName string, args []string) ([]byte, error) {
// Prepend chaincode function name to argument list
args = append([]string{ccFunctionName}, args...)
// Create channel client
channelClient, err := w.createChannelClient(... | func (s *SmartContract) queryLedger(APIstub shim.ChaincodeStubInterface, args []string) sc.Response {
if len(args) != 1 {
return shim.Error("Incorrect number of arguments. Expecting 1 (i.e., the provided token)")
}
owner := args[0];
// fmt.Printf("Cars belong to: " + owner);
queryString := ... | func (p *Projector) Volumes(ctx context.Context, blocks []string) (map[string]int, error) {
toReturn := make(map[string]int)
resp, err := p.SendCommand(ctx, p.Address, volumeStatus)
if err != nil {
return toReturn, err
}
volume, err := strconv.Atoi(resp)
if err != nil {
return toReturn, err
}
toReturn[""... | func (o LicenseMasterSpecVolumesQuobyteOutput) Volume() pulumi.StringOutput {
return o.ApplyT(func(v LicenseMasterSpecVolumesQuobyte) string { return v.Volume }).(pulumi.StringOutput)
} | func (api *API) SearchVolume(vi *VolumeInfo) ([]*VolumeInfo, error) {
queryURL := api.buildQueryURL(vi)
if len(queryURL) == 0 {
return nil, nil
}
resp, err := http.Get(queryURL)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, fmt.Errorf("googlebooks: que... | func (r *Query) CacheVolume(key string) *CacheVolume {
q := r.q.Select("cacheVolume")
q = q.Arg("key", key)
return &CacheVolume{
q: q,
c: r.c,
}
} | func QueryVirtualCenters(vcdClient *VCDClient, filter string) ([]*types.QueryResultVirtualCenterRecordType, error) {
results, err := vcdClient.QueryWithNotEncodedParams(nil, map[string]string{
"type": "virtualCenter",
"filter": filter,
})
if err != nil {
return nil, err
}
return results.Results.VirtualCen... | func GetVolume(ctx *datastore.VersionedContext, i IntData, e ExtData, r *ROI) ([]byte, error) {
if err := GetVoxels(ctx, i, e, r); err != nil {
return nil, err
}
return e.Data(), nil
} | func filterVolumes(volumes []*db.StorageVolume, clauses *filter.ClauseSet, allProjects bool, filterProjectImages []string) ([]*db.StorageVolume, error) {
// FilterStorageVolume is for filtering purpose only.
// It allows to filter snapshots by using default filter mechanism.
type FilterStorageVolume struct {
api.S... | func (c *CmdVolumeStatsOptions) RunVolumeStats(cmd *cobra.Command) error {
fmt.Println("Executing volume stats...")
var (
err, err1, err3 error
err2, err4 int
status v1.VolStatus
stats1, stats2 v1.VolumeMetrics
repStatus string
statusArray []string //keeps track of the replica's ... | func (a *postgresqlQueryShowAction) Run(ctx context.Context) ([]byte, error) {
dsn, err := templates.RenderDSN(a.params.Dsn, a.params.TlsFiles, filepath.Join(a.tempDir, strings.ToLower(a.Type()), a.id))
if err != nil {
return nil, errors.WithStack(err)
}
connector, err := pq.NewConnector(dsn)
if err != nil {
... | func (self *BoltStatStorage) GetUserVolume(fromTime uint64, toTime uint64, freq string, ethUserAddr ethereum.Address) (common.StatTicks, error) {
result := common.StatTicks{}
userAddr := common.AddrToString(ethUserAddr)
err := self.db.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte(userAddr))
if b == nil {
... | func (a *Adapter) buildVolumes(containers, initContainers []corev1.Container) ([]corev1.Volume, error) {
runtime := component.GetComponentRuntimeFromDevfileMetadata(a.Devfile.Data.GetMetadata())
storageClient := storagepkg.NewClient(a.ComponentName, a.AppName, storagepkg.ClientOptions{
Client: a.kubeClient,
Ru... | func (m *QueryExecutor) ExecuteQueryOnPrivateData(namespace, collection, query string) (commonledger.ResultsIterator, error) {
panic("not implemented")
} | func (storage *AzureStorage) Query(q dsq.Query) (dsq.Results, error) {
return nil, fmt.Errorf("Azure storage query not supported")
} | func queryCoinCap(start, end time.Time, granularity Granularity) ([]byte,
error) {
// The coincap api requires milliseconds.
startMs := start.Unix() * 1000
endMs := end.Unix() * 1000
url := fmt.Sprintf("%v?interval=%v&start=%v&end=%v",
coinCapHistoryAPI, granularity.label, startMs,
endMs)
log.Debugf("coinca... | func queryKV(key string) ([]contact, error) {
cont, err := db.View(func(tx *bolt.Tx) ([]contact, error) {
retValue := tx.Bucket([]byte("Files")).Get([]byte(key))
//fmt.Printf("The value of '%s' is: %v\n", key, retValue)
return (retValue,nil)
})
if err != nil {
fmt.Printf("Internal DB err... | func (b *BasicQuery) Run(ctx context.Context) *Result {
results := NewResult()
if b.client == nil {
results.err = fmt.Errorf("No client set for BasicQuery")
return results
}
bms := make([]*pql.Call, b.NumArgs)
for i, _ := range bms {
bms[i] = &pql.Call{
Name: "Bitmap",
Args: map[string]interface{}{"fr... | func queryRangeLog(
conn *gosql.DB, query string, args ...interface{},
) ([]kvserverpb.RangeLogEvent_Info, error) {
// The range log can get large and sees unpredictable writes, so run this in a
// proper txn to avoid spurious retries.
var events []kvserverpb.RangeLogEvent_Info
err := crdb.ExecuteTx(context.Backg... | func (s *SmartContract) queryByOwner(APIstub shim.ChaincodeStubInterface, args []string) sc.Response {
if len(args) < 1 {
return shim.Error("Incorrect number of arguments. Expecting 1")
}
name := args[0]
queryString := fmt.Sprintf("{\"selector\":{\"owner\":\"%s\"}}", name)
resultsIterator, err := APIstub.Ge... | func (d *DB) QueryPrimitive(ctx context.Context, statement string, _ string, args ...interface{}) (connection.ResultFetch, error) {
var rows pgx.Rows
var err error
var connQ func(context.Context, string, ...interface{}) (pgx.Rows, error)
if d.tx != nil {
connQ = d.tx.Query
} else if d.conn != nil {
connQ = d.c... | func (s *Service) runContinuousQueryAndWriteResult(cq *ContinuousQuery) *query.Result {
// Wrap the CQ's inner SELECT statement in a Query for the Executor.
q := &influxql.Query{
Statements: influxql.Statements([]influxql.Statement{cq.q}),
}
closing := make(chan struct{})
defer close(closing)
// Execute the S... | func (client BlockstorageClient) getVolume(ctx context.Context, request common.OCIRequest, binaryReqBody *common.OCIReadSeekCloser, extraHeaders map[string]string) (common.OCIResponse, error) {
httpRequest, err := request.HTTPRequest(http.MethodGet, "/volumes/{volumeId}", binaryReqBody, extraHeaders)
if err != nil {... | func (h *ClickhouseQueryHandler) Query(ctx context.Context, project, service, database, query string) (*ClickhouseQueryResponse, error) {
path := buildPath("project", project, "service", service, "clickhouse", "query")
bts, err := h.client.doPostRequest(ctx, path, ClickhouseQueryRequest{
Database: database,
Query... | func runQuery(root *doltdb.RootValue, dEnv *env.DoltEnv, query string) (*doltdb.RootValue, error) {
db := sqle.NewDatabase("dolt", root, dEnv.DoltDB, dEnv.RepoState)
engine := sqlServer.NewDefault()
engine.AddDatabase(db)
_ = engine.Init()
sqlCtx := sql.NewContext(context.Background())
_, _, err := engine.Query(s... | func buildLunQueryResults(numLuns int) interface{} {
testSlice := []LunInfo{}
for i := 1; i <= numLuns; i++ {
lun := LunInfo{
HostClusterID: 1,
VolumeID: 1,
CLustered: false,
HostID: 1,
ID: i,
Lun: 1234567890,
}
testSlice = append(testSlice, lun)
}
re... | func RunQuery(channelStats chan int, queryNumber int, session *mgo.Session, points int32) {
start := time.Now()
sessionCopy := session.Copy()
defer sessionCopy.Close()
customers := sessionCopy.DB("customer").C("customer")
_, err := customers.Find(bson.M{
"points": bson.M{"$lte": points},
}).Count()
if err... | func (db *Database) RunQuery(opts QueryOptions) (QueryResponse, error) {
queryResponse := QueryResponse{}
// Open a connection to the database
dbase, err := sqlx.Open("sqlite3", db.File)
if err != nil {
return queryResponse, fmt.Errorf("error while opening connection to database: %s", err.Error())
}
defer dbas... | func (connector *InfluxConnector) query(cmd string) (res []client.Result, err error) {
q := client.Query{
Command: cmd,
Database: connector.database,
}
if response, err := connector.c.Query(q); err == nil {
if response.Error() != nil {
return res, response.Error()
}
res = response.Results
}
return ... | func GetOutputRowPVCFromPodAndVolume(ctx context.Context, clientset *kubernetes.Clientset, pod *Pod, vol *Volume, desiredNamespace string) *OutputRowPVC {
var outputRowPVC *OutputRowPVC
if 0 < len(desiredNamespace) {
if vol.PvcRef.PvcNamespace != desiredNamespace {
return nil
}
}
log.Debugf("restricting fin... | func (db *LevelDB) RawRangeQuery(kStart, kEnd storage.Key, keysOnly bool, out chan *storage.KeyValue, cancel <-chan struct{}) error {
if db == nil {
return fmt.Errorf("Can't call RawRangeQuery on nil LevelDB")
}
ro := levigo.NewReadOptions()
it := db.ldb.NewIterator(ro)
defer it.Close()
var itValue []byte
it.... | func (q Query) Run(seq int, args ...interface{}) error {
key := fmt.Sprintf("key_%d", seq)
param := []string{key}
_, err := Clis[seq].Query(CHAINCODE, "query", param)
return err
} | func queryDB(clnt influx.Client, cmd string, db string) (res []influx.Result, err error) {
q := influx.Query{
Command: cmd,
Database: db,
}
if response, err := clnt.Query(q); err == nil {
if response.Error() != nil {
return res, response.Error()
}
res = response.Results
} else {
return res, err
}
... | func query(ctx context.Context, client *bigquery.Client) (*bigquery.RowIterator, error) {
query := client.Query(
`SELECT
concat(word, ":", corpus) as RowKey,
<dataset-id>.toMyProtoMessage(
STRUCT(
word,
CAST(word_count AS BIGNUMERIC)
)
) AS ProtoResult
FROM
` + "` bigquery - public ... | func (s *Service) runContinuousQueries(req *RunRequest) {
// Get list of all databases.
dbs, _ := s.MetaClient.Databases()
// Loop through all databases executing CQs.
for _, db := range dbs {
// TODO: distribute across nodes
for _, cq := range db.ContinuousQueries {
if !req.matches(&cq) {
continue
}
... | func (d *driver) Volumes(
ctx types.Context,
opts *types.VolumesOpts) ([]*types.Volume, error) {
list, err := mustSession(ctx).blobClient.ListBlobs(d.container,
blobStorage.ListBlobsParameters{Include: "metadata"})
if err != nil {
return nil, goof.WithError("error listing blobs", err)
}
// Convert retrieved ... | func (br *Broker) ExecuteQuerySingleReplica(ctx context.Context, database string, qry string, shardIn *meta.Shard, isPrimary bool) ([]*query.Result, error) {
shard := shardIn
// parse the query
pq, err := influxql.ParseQuery(qry)
if err != nil {
return nil, err
}
// get the cluster
cl := br.GetCluster(meta.Cl... | func (br *Broker) ExecuteQuerySingle(ctx context.Context, database string, qry string, shardIn *meta.Shard) ([]*query.Result, error) {
shard := shardIn
// parse the query
pq, err := influxql.ParseQuery(qry)
if err != nil {
return nil, err
}
// get the cluster
cl := br.GetCluster(meta.ClusterTypeTstore)
if cl... | func (client *Client) cumulativeQueryWithHeaders(queryType string, params, notEncodedParams map[string]string, headers map[string]string) (Results, error) {
var supportedQueryTypes = []string{
types.QtVappTemplate,
types.QtAdminVappTemplate,
types.QtEdgeGateway,
types.QtOrgVdcNetwork,
types.QtCatalog,
type... | func (s *SlicingDiceTester) executeQuery(queryType string, test map[string]interface{}) (map[string]interface{}, error) {
var result interface{}
var err error
if queryType == "sql" {
result, err = s.client.Sql(test["query"].(string))
if result == nil {
return nil, err
}
return result.(map[string]interfa... | func (t *BlockChainTaskChainCode) querySpecificVehicle(stub shim.ChaincodeStubInterface, args []string) pb.Response {
if len(args) < 1 {
return shim.Error("Incorrect number of arguments. Expecting 1")
}
vehicleID := args[0]
queryString := fmt.Sprintf("{\"selector\":{\"docType\":\"vehicles\",\"vehicleID\":\"%s... | func (m *QueryExecutor) ExecuteQueryOnPrivateData(namespace, collection, query string) (commonledger.ResultsIterator, error) {
if m.error != nil {
return nil, m.error
}
return m.itProvider().WithResults(m.queryResults[privateQueryResultsKey(namespace, collection, query)]), m.error
} | func runCardQueries(ctx context.Context, tconn *chrome.TestConn, ui *uiauto.Context) error {
for _, q := range []string{"Mount Everest", "Weather"} {
if err := runCardQuery(ctx, tconn, ui, q); err != nil {
return err
}
}
return nil
} | func (q *lockBasedQueryExecutor) ExecuteQueryOnPrivateData(namespace, collection, query string) (commonledger.ResultsIterator, error) {
return q.helper.executeQueryOnPrivateData(namespace, collection, query)
} | func (a *ServersApiService) DatacentersServersVolumesGetExecute(r ApiDatacentersServersVolumesGetRequest) (AttachedVolumes, *APIResponse, error) {
var (
localVarHTTPMethod = _nethttp.MethodGet
localVarPostBody interface{}
localVarFormFileName string
localVarFileName string
localVarFileBytes []by... | func RunQueries(config *Config, address string, timeout time.Duration, requestData map[string]interface{}) (interface{}, error) {
var promData Data
err := helpers.MapToStruct(requestData, &promData)
if err != nil {
return nil, err
}
roundTripper := api.DefaultRoundTripper
username := requestData["username"].(... | func (o QuobyteVolumeSourceOutput) Volume() pulumi.StringOutput {
return o.ApplyT(func(v QuobyteVolumeSource) string { return v.Volume }).(pulumi.StringOutput)
} | func RunVolumeCreate(c *CmdConfig) error {
if len(c.Args) == 0 {
return doctl.NewMissingArgsErr(c.NS)
}
name := c.Args[0]
sizeStr, err := c.Doit.GetString(c.NS, doctl.ArgVolumeSize)
if err != nil {
return err
}
size, err := humanize.ParseBytes(sizeStr)
if err != nil {
return err
}
desc, err := c.Doit... | func queryData(ctx context.Context, queries []backend.DataQuery, dsInfo *es.DatasourceInfo) (*backend.QueryDataResponse, error) {
if len(queries) == 0 {
return &backend.QueryDataResponse{}, fmt.Errorf("query contains no queries")
}
client, err := es.NewClient(ctx, dsInfo, queries[0].TimeRange)
if err != nil {
... | func (t *Sharing) queryDataByOwner(stub shim.ChaincodeStubInterface, args []string) pb.Response {
// 0 1
// "owner" "minhash"
if len(args) < 11 {
return shim.Error("Incorrect number of arguments. Expecting 1")
}
traversehelper := strings.ToLower(args[0])
minhash := args[1]
... | func (c Client) Volumes(ctx context.Context) (*[]*FileSystem, error) {
var filesystems []*FileSystem
cPools := c.CapacityPools()
for _, cPool := range *cPools {
poolFilesystems, err := c.getVolumesFromPool(ctx, cPool)
if err != nil {
Logc(ctx).WithError(err).Errorf("Error fetching volumes from pool %s.", c... | func (b *localBackend) query(ctx context.Context, op backend.QueryOperation,
callerEventsOpt chan<- engine.Event,
) result.Result {
return backend.RunQuery(ctx, b, op, callerEventsOpt, b.newQuery)
} | func (v *QueryClient) Query(namespace, cloudRegion, apiVersion, kind, name, labels string) (QueryStatus, error) {
//Read the status from the DD
k8sClient := KubernetesClient{}
err := k8sClient.Init(cloudRegion, "dummy") //we don't care about instance id in this request
if err != nil {
return QueryStatus{}, pkge... | func (sc *snowflakeConn) rowsForRunningQuery(ctx context.Context, qid string, rows *snowflakeRows) error {
resultPath := fmt.Sprintf(urlQueriesResultFmt, qid)
resp, err := sc.getQueryResultResp(ctx, resultPath)
if err != nil {
logger.WithContext(ctx).Errorf("error: %v", err)
if resp != nil {
code, err := strc... | func Run(gRPCAddress, marketID, partyID string) error {
f, err := os.OpenFile("liquidity.log", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("error opening file: %v", err)
}
defer f.Close()
log.SetOutput(f)
// Create connection to vega
connection, err := grpc.Dial(gRPCAddress, grpc.WithI... | func (c *PersistentVolumeCollector) Run(rcfg *collectors.CollectorRunConfig) (*collectors.CollectorRunResult, error) {
list, err := c.lister.List(labels.Everything())
if err != nil {
return nil, collectors.NewListingError(err)
}
ctx := collectors.NewProcessorContext(rcfg, c.metadata)
processResult, processed :... | func (opts ListOpts) ToVolumeListQuery() (string, error) {
q, err := gophercloud.BuildQueryString(opts)
return q.String(), err
} | [
"0.5445938",
"0.52377886",
"0.5204298",
"0.5136511",
"0.5124792",
"0.51123863",
"0.5112245",
"0.49972367",
"0.49674076",
"0.49402845",
"0.48979104",
"0.48817298",
"0.48711815",
"0.4866479",
"0.4858121",
"0.48578903",
"0.48532462",
"0.4849372",
"0.48399466",
"0.48337623",
"0.4... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.