_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5400 | Email | train | func Email() string {
return strings.ToLower(FirstName(RandomGender)+LastName()) + StringNumberExt(1, "", 3) + "@" + randomFrom(jsonData.Domains)
} | go | {
"resource": ""
} |
q5401 | Country | train | func Country(countryStyle int64) string {
country := ""
switch countryStyle {
default:
case FullCountry:
country = randomFrom(jsonData.Countries)
break
case TwoCharCountry:
country = randomFrom(jsonData.CountriesTwoChars)
break
case ThreeCharCountry:
country = randomFrom(jsonData.CountriesThreeChars... | go | {
"resource": ""
} |
q5402 | State | train | func State(typeOfState int) string {
if typeOfState == Small {
return randomFrom(jsonData.StatesSmall)
}
return randomFrom(jsonData.States)
} | go | {
"resource": ""
} |
q5403 | Street | train | func Street() string {
return fmt.Sprintf("%s %s", randomFrom(jsonData.People), randomFrom(jsonData.StreetTypes))
} | go | {
"resource": ""
} |
q5404 | StreetForCountry | train | func StreetForCountry(countrycode string) string {
switch countrycode {
case "US":
return Street()
case "GB":
return fmt.Sprintf("%s %s", randomFrom(jsonData.StreetNameGB), randomFrom(jsonData.StreetTypesGB))
}
return ""
} | go | {
"resource": ""
} |
q5405 | Address | train | func Address() string {
return fmt.Sprintf("%d %s,\n%s, %s, %s", Number(100), Street(), City(), State(Small), PostalCode("US"))
} | go | {
"resource": ""
} |
q5406 | StringSample | train | func StringSample(stringList ...string) string {
str := ""
if len(stringList) > 0 {
str = stringList[Number(0, len(stringList))]
}
return str
} | go | {
"resource": ""
} |
q5407 | IpV4Address | train | func IpV4Address() string {
blocks := []string{}
for i := 0; i < 4; i++ {
number := privateRand.Intn(255)
blocks = append(blocks, strconv.Itoa(number))
}
return strings.Join(blocks, ".")
} | go | {
"resource": ""
} |
q5408 | IpV6Address | train | func IpV6Address() string {
var ip net.IP
for i := 0; i < net.IPv6len; i++ {
number := uint8(privateRand.Intn(255))
ip = append(ip, number)
}
return ip.String()
} | go | {
"resource": ""
} |
q5409 | MacAddress | train | func MacAddress() string {
blocks := []string{}
for i := 0; i < 6; i++ {
number := fmt.Sprintf("%02x", privateRand.Intn(255))
blocks = append(blocks, number)
}
return strings.Join(blocks, ":")
} | go | {
"resource": ""
} |
q5410 | FullDate | train | func FullDate() string {
timestamp := time.Now()
year := timestamp.Year()
month := Number(1, 13)
maxDay := time.Date(year, time.Month(month+1), 0, 0, 0, 0, 0, time.UTC).Day()
day := Number(1, maxDay+1)
date := time.Date(year, time.Month(month), day, 0, 0, 0, 0, time.UTC)
return date.Format(DateOutputLayout)
} | go | {
"resource": ""
} |
q5411 | update | train | func (d *device) update() error {
if d.advParam != nil {
if err := d.hci.SendCmdWithAdvOff(d.advParam); err != nil {
return err
}
d.advParam = nil
}
if d.scanResp != nil {
if err := d.hci.SendCmdWithAdvOff(d.scanResp); err != nil {
return err
}
d.scanResp = nil
}
if d.advData != nil {
if err :=... | go | {
"resource": ""
} |
q5412 | LnxDeviceID | train | func LnxDeviceID(n int, chk bool) Option {
return func(d Device) error {
d.(*device).devID = n
d.(*device).chkLE = chk
return nil
}
} | go | {
"resource": ""
} |
q5413 | LnxMaxConnections | train | func LnxMaxConnections(n int) Option {
return func(d Device) error {
d.(*device).maxConn = n
return nil
}
} | go | {
"resource": ""
} |
q5414 | LnxSetAdvertisingEnable | train | func LnxSetAdvertisingEnable(en bool) Option {
return func(d Device) error {
dd := d.(*device)
if dd == nil {
return errors.New("device is not initialized")
}
if err := dd.update(); err != nil {
return err
}
return dd.hci.SetAdvertiseEnable(en)
}
} | go | {
"resource": ""
} |
q5415 | LnxSetAdvertisingData | train | func LnxSetAdvertisingData(c *cmd.LESetAdvertisingData) Option {
return func(d Device) error {
d.(*device).advData = c
return nil
}
} | go | {
"resource": ""
} |
q5416 | LnxSetScanResponseData | train | func LnxSetScanResponseData(c *cmd.LESetScanResponseData) Option {
return func(d Device) error {
d.(*device).scanResp = c
return nil
}
} | go | {
"resource": ""
} |
q5417 | LnxSetAdvertisingParameters | train | func LnxSetAdvertisingParameters(c *cmd.LESetAdvertisingParameters) Option {
return func(d Device) error {
d.(*device).advParam = c
return nil
}
} | go | {
"resource": ""
} |
q5418 | LnxSendHCIRawCommand | train | func LnxSendHCIRawCommand(c cmd.CmdParam, rsp io.Writer) Option {
return func(d Device) error {
b, err := d.(*device).SendHCIRawCommand(c)
if rsp == nil {
return err
}
rsp.Write(b)
return err
}
} | go | {
"resource": ""
} |
q5419 | MacDeviceRole | train | func MacDeviceRole(r int) Option {
return func(d Device) error {
d.(*device).role = r
return nil
}
} | go | {
"resource": ""
} |
q5420 | IoW | train | func IoW(t, nr, size uintptr) uintptr {
return ioc(directionWrite, t, nr, size)
} | go | {
"resource": ""
} |
q5421 | IoRW | train | func IoRW(t, nr, size uintptr) uintptr {
return ioc(directionRead|directionWrite, t, nr, size)
} | go | {
"resource": ""
} |
q5422 | NewCharacteristic | train | func NewCharacteristic(u UUID, s *Service, props Property, h uint16, vh uint16) *Characteristic {
c := &Characteristic{
uuid: u,
svc: s,
props: props,
h: h,
vh: vh,
}
return c
} | go | {
"resource": ""
} |
q5423 | NewDescriptor | train | func NewDescriptor(u UUID, h uint16, char *Characteristic) *Descriptor {
cd := &Descriptor{
uuid: u,
h: h,
char: char,
}
return cd
} | go | {
"resource": ""
} |
q5424 | xpcToGo | train | func xpcToGo(v C.xpc_object_t) interface{} {
t := C.xpc_get_type(v)
switch t {
case C.TYPE_ARRAY:
a := make(Array, C.int(C.xpc_array_get_count(v)))
C.XpcArrayApply(unsafe.Pointer(&a), v)
return a
case C.TYPE_DATA:
return C.GoBytes(C.xpc_data_get_bytes_ptr(v), C.int(C.xpc_data_get_length(v)))
case C.TYPE... | go | {
"resource": ""
} |
q5425 | unmarshall | train | func (a *Advertisement) unmarshall(b []byte) error {
// Utility function for creating a list of uuids.
uuidList := func(u []UUID, d []byte, w int) []UUID {
for len(d) > 0 {
u = append(u, UUID{d[:w]})
d = d[w:]
}
return u
}
for len(b) > 0 {
if len(b) < 2 {
return errors.New("invalid advertise data... | go | {
"resource": ""
} |
q5426 | Bytes | train | func (a *AdvPacket) Bytes() [31]byte {
b := [31]byte{}
copy(b[:], a.b)
return b
} | go | {
"resource": ""
} |
q5427 | Len | train | func (a *AdvPacket) Len() int {
if len(a.b) > 31 {
return 31
}
return len(a.b)
} | go | {
"resource": ""
} |
q5428 | AppendFlags | train | func (a *AdvPacket) AppendFlags(f byte) *AdvPacket {
return a.AppendField(typeFlags, []byte{f})
} | go | {
"resource": ""
} |
q5429 | AppendName | train | func (a *AdvPacket) AppendName(n string) *AdvPacket {
typ := byte(typeCompleteName)
if len(a.b)+2+len(n) > MaxEIRPacketLength {
typ = byte(typeShortName)
}
return a.AppendField(typ, []byte(n))
} | go | {
"resource": ""
} |
q5430 | AppendManufacturerData | train | func (a *AdvPacket) AppendManufacturerData(id uint16, b []byte) *AdvPacket {
d := append([]byte{uint8(id), uint8(id >> 8)}, b...)
return a.AppendField(typeManufacturerData, d)
} | go | {
"resource": ""
} |
q5431 | AppendUUIDFit | train | func (a *AdvPacket) AppendUUIDFit(uu []UUID) bool {
// Iterate all UUIDs to see if they fit in the packet or not.
fit, l := true, len(a.b)
for _, u := range uu {
if u.Equal(attrGAPUUID) || u.Equal(attrGATTUUID) {
continue
}
l += 2 + u.Len()
if l > MaxEIRPacketLength {
fit = false
break
}
}
// A... | go | {
"resource": ""
} |
q5432 | Close | train | func (c *conn) Close() error {
h := c.hci
hh := c.attr
h.connsmu.Lock()
defer h.connsmu.Unlock()
_, found := h.conns[hh]
if !found {
// log.Printf("l2conn: 0x%04x already disconnected", hh)
return nil
}
if err, _ := h.c.Send(cmd.Disconnect{ConnectionHandle: hh, Reason: 0x13}); err != nil {
return fmt.Erro... | go | {
"resource": ""
} |
q5433 | handleSignal | train | func (c *conn) handleSignal(a *aclData) error {
log.Printf("ignore l2cap signal:[ % X ]", a.b)
// FIXME: handle LE signaling channel (CID: 5)
return nil
} | go | {
"resource": ""
} |
q5434 | ParseUUID | train | func ParseUUID(s string) (UUID, error) {
s = strings.Replace(s, "-", "", -1)
b, err := hex.DecodeString(s)
if err != nil {
return UUID{}, err
}
if err := lenErr(len(b)); err != nil {
return UUID{}, err
}
return UUID{reverse(b)}, nil
} | go | {
"resource": ""
} |
q5435 | MustParseUUID | train | func MustParseUUID(s string) UUID {
u, err := ParseUUID(s)
if err != nil {
panic(err)
}
return u
} | go | {
"resource": ""
} |
q5436 | Equal | train | func (u UUID) Equal(v UUID) bool {
return bytes.Equal(u.b, v.b)
} | go | {
"resource": ""
} |
q5437 | reverse | train | func reverse(u []byte) []byte {
// Special-case 16 bit UUIDS for speed.
l := len(u)
if l == 2 {
return []byte{u[1], u[0]}
}
b := make([]byte, l)
for i := 0; i < l/2+1; i++ {
b[i], b[l-i-1] = u[l-i-1], u[i]
}
return b
} | go | {
"resource": ""
} |
q5438 | Handle | train | func (d *device) Handle(hh ...Handler) {
for _, h := range hh {
h(d)
}
} | go | {
"resource": ""
} |
q5439 | CentralConnected | train | func CentralConnected(f func(Central)) Handler {
return func(d Device) { d.(*device).centralConnected = f }
} | go | {
"resource": ""
} |
q5440 | CentralDisconnected | train | func CentralDisconnected(f func(Central)) Handler {
return func(d Device) { d.(*device).centralDisconnected = f }
} | go | {
"resource": ""
} |
q5441 | PeripheralDiscovered | train | func PeripheralDiscovered(f func(Peripheral, *Advertisement, int)) Handler {
return func(d Device) { d.(*device).peripheralDiscovered = f }
} | go | {
"resource": ""
} |
q5442 | PeripheralConnected | train | func PeripheralConnected(f func(Peripheral, error)) Handler {
return func(d Device) { d.(*device).peripheralConnected = f }
} | go | {
"resource": ""
} |
q5443 | PeripheralDisconnected | train | func PeripheralDisconnected(f func(Peripheral, error)) Handler {
return func(d Device) { d.(*device).peripheralDisconnected = f }
} | go | {
"resource": ""
} |
q5444 | Option | train | func (d *device) Option(opts ...Option) error {
var err error
for _, opt := range opts {
err = opt(d)
}
return err
} | go | {
"resource": ""
} |
q5445 | At | train | func (r *attrRange) At(h uint16) (a attr, ok bool) {
i := r.idx(int(h))
if i < 0 {
return attr{}, false
}
return r.aa[i], true
} | go | {
"resource": ""
} |
q5446 | Chunk | train | func (w *l2capWriter) Chunk() {
if w.chunked {
panic("l2capWriter: chunk called twice without committing")
}
w.chunked = true
if w.chunk == nil {
w.chunk = make([]byte, 0, w.mtu)
}
} | go | {
"resource": ""
} |
q5447 | Commit | train | func (w *l2capWriter) Commit() bool {
if !w.chunked {
panic("l2capWriter: commit without starting a chunk")
}
var success bool
if len(w.b)+len(w.chunk) <= w.mtu {
success = true
w.b = append(w.b, w.chunk...)
}
w.chunk = w.chunk[:0]
w.chunked = false
return success
} | go | {
"resource": ""
} |
q5448 | CommitFit | train | func (w *l2capWriter) CommitFit() {
if !w.chunked {
panic("l2capWriter: CommitFit without starting a chunk")
}
writeable := w.mtu - len(w.b)
if writeable > len(w.chunk) {
writeable = len(w.chunk)
}
w.b = append(w.b, w.chunk[:writeable]...)
w.chunk = w.chunk[:0]
w.chunked = false
} | go | {
"resource": ""
} |
q5449 | WriteByteFit | train | func (w *l2capWriter) WriteByteFit(b byte) bool {
return w.WriteFit([]byte{b})
} | go | {
"resource": ""
} |
q5450 | Writeable | train | func (w *l2capWriter) Writeable(pad int, b []byte) int {
if w.chunked {
return len(b)
}
avail := w.mtu - len(w.b) - pad
if avail > len(b) {
return len(b)
}
if avail < 0 {
return 0
}
return avail
} | go | {
"resource": ""
} |
q5451 | ChunkSeek | train | func (w *l2capWriter) ChunkSeek(offset uint16) bool {
if !w.chunked {
panic("l2capWriter: ChunkSeek requested without chunked write in progress")
}
if len(w.chunk) < int(offset) {
w.chunk = w.chunk[:0]
return false
}
w.chunk = w.chunk[offset:]
return true
} | go | {
"resource": ""
} |
q5452 | Validate | train | func Validate(passcode string, counter uint64, secret string) bool {
rv, _ := ValidateCustom(
passcode,
counter,
secret,
ValidateOpts{
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
},
)
return rv
} | go | {
"resource": ""
} |
q5453 | GenerateCode | train | func GenerateCode(secret string, counter uint64) (string, error) {
return GenerateCodeCustom(secret, counter, ValidateOpts{
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
})
} | go | {
"resource": ""
} |
q5454 | GenerateCodeCustom | train | func GenerateCodeCustom(secret string, counter uint64, opts ValidateOpts) (passcode string, err error) {
// As noted in issue #10 and #17 this adds support for TOTP secrets that are
// missing their padding.
secret = strings.TrimSpace(secret)
if n := len(secret) % 8; n != 0 {
secret = secret + strings.Repeat("=",... | go | {
"resource": ""
} |
q5455 | Generate | train | func Generate(opts GenerateOpts) (*otp.Key, error) {
// url encode the Issuer/AccountName
if opts.Issuer == "" {
return nil, otp.ErrGenerateMissingIssuer
}
if opts.AccountName == "" {
return nil, otp.ErrGenerateMissingAccountName
}
if opts.SecretSize == 0 {
opts.SecretSize = 10
}
if opts.Digits == 0 {
... | go | {
"resource": ""
} |
q5456 | Validate | train | func Validate(passcode string, secret string) bool {
rv, _ := ValidateCustom(
passcode,
secret,
time.Now().UTC(),
ValidateOpts{
Period: 30,
Skew: 1,
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
},
)
return rv
} | go | {
"resource": ""
} |
q5457 | GenerateCode | train | func GenerateCode(secret string, t time.Time) (string, error) {
return GenerateCodeCustom(secret, t, ValidateOpts{
Period: 30,
Skew: 1,
Digits: otp.DigitsSix,
Algorithm: otp.AlgorithmSHA1,
})
} | go | {
"resource": ""
} |
q5458 | Issuer | train | func (k *Key) Issuer() string {
q := k.url.Query()
issuer := q.Get("issuer")
if issuer != "" {
return issuer
}
p := strings.TrimPrefix(k.url.Path, "/")
i := strings.Index(p, ":")
if i == -1 {
return ""
}
return p[:i]
} | go | {
"resource": ""
} |
q5459 | AccountName | train | func (k *Key) AccountName() string {
p := strings.TrimPrefix(k.url.Path, "/")
i := strings.Index(p, ":")
if i == -1 {
return p
}
return p[i+1:]
} | go | {
"resource": ""
} |
q5460 | Secret | train | func (k *Key) Secret() string {
q := k.url.Query()
return q.Get("secret")
} | go | {
"resource": ""
} |
q5461 | Format | train | func (d Digits) Format(in int32) string {
f := fmt.Sprintf("%%0%dd", d)
return fmt.Sprintf(f, in)
} | go | {
"resource": ""
} |
q5462 | build | train | func build() bool {
log.Println(okColor("Running build command!"))
args := strings.Split(*flag_build, " ")
if len(args) == 0 {
// If the user has specified and empty then we are done.
return true
}
cmd := exec.Command(args[0], args[1:]...)
if *flag_build_dir != "" {
cmd.Dir = *flag_build_dir
} else {
... | go | {
"resource": ""
} |
q5463 | builder | train | func builder(jobs <-chan string, buildStarted chan<- string, buildDone chan<- bool) {
createThreshold := func() <-chan time.Time {
return time.After(time.Duration(WorkDelay * time.Millisecond))
}
threshold := createThreshold()
eventPath := ""
for {
select {
case eventPath = <-jobs:
threshold = createThr... | go | {
"resource": ""
} |
q5464 | startCommand | train | func startCommand(command string) (cmd *exec.Cmd, stdout io.ReadCloser, stderr io.ReadCloser, err error) {
args := strings.Split(command, " ")
cmd = exec.Command(args[0], args[1:]...)
if *flag_run_dir != "" {
cmd.Dir = *flag_run_dir
}
if stdout, err = cmd.StdoutPipe(); err != nil {
err = fmt.Errorf("can't g... | go | {
"resource": ""
} |
q5465 | runner | train | func runner(commandTemplate string, buildStarted <-chan string, buildSuccess <-chan bool) {
var currentProcess *os.Process
pipeChan := make(chan io.ReadCloser)
go logger(pipeChan)
go func() {
sigChan := make(chan os.Signal, 1)
signal.Notify(sigChan, fatalSignals...)
<-sigChan
log.Println(okColor("Received... | go | {
"resource": ""
} |
q5466 | Less | train | func (f FunctionNameList) Less(i, j int) bool {
if f[i].Str == "" && f[j].Str != "" {
return true
}
if f[i].Str != "" && f[j].Str == "" {
return false
}
if f[i].Str != "" && f[j].Str != "" {
if f[i].Str > f[j].Str {
return true
} else if f[i].Str < f[j].Str {
return false
}
}
return f[i].Name < f... | go | {
"resource": ""
} |
q5467 | NewWriter | train | func NewWriter(writer io.Writer, codec Codec, recordsPerBlock int64, schema string) (*Writer, error) {
blockBytes := make([]byte, 0)
blockBuffer := bytes.NewBuffer(blockBytes)
avroWriter := &Writer{
writer: writer,
syncMarker: [16]byte{'g', 'o', 'g', 'e', 'n', 'a', 'v', 'r', 'o', 'm', 'a', 'g', 'i... | go | {
"resource": ""
} |
q5468 | WriteRecord | train | func (avroWriter *Writer) WriteRecord(record AvroRecord) error {
var err error
// Serialize the new record into the compressed writer
err = record.Serialize(avroWriter.compressedWriter)
if err != nil {
return err
}
avroWriter.nextBlockRecords += 1
// If the block if full, flush and reset the compressed writer... | go | {
"resource": ""
} |
q5469 | Flush | train | func (avroWriter *Writer) Flush() error {
if avroWriter.nextBlockRecords == 0 {
return nil
}
// Write out all of the buffered records as a new block
// Must be called before closing to ensure the last block is written
if fwWriter, ok := avroWriter.compressedWriter.(CloseableResettableWriter); ok {
fwWriter.Cl... | go | {
"resource": ""
} |
q5470 | NewNamespaceNamer | train | func NewNamespaceNamer(shortNames bool) *NamespaceNamer {
return &NamespaceNamer{shortNames: shortNames, re: regexp.MustCompile(invalidTokensExpr)}
} | go | {
"resource": ""
} |
q5471 | ToPublicName | train | func (n *NamespaceNamer) ToPublicName(name string) string {
if n.shortNames {
if parts := strings.Split(name, "."); len(parts) > 2 {
name = strings.Join(parts[len(parts)-2:], ".")
}
}
name = n.re.ReplaceAllString(name, " ")
return strings.Replace(strings.Title(name), " ", "", -1)
} | go | {
"resource": ""
} |
q5472 | CompileToVM | train | func (b *blockStartIRInstruction) CompileToVM(p *irProgram) ([]vm.Instruction, error) {
block := p.blocks[b.blockId]
return []vm.Instruction{
vm.Instruction{vm.Read, vm.Long},
vm.Instruction{vm.EvalEqual, 0},
vm.Instruction{vm.CondJump, block.end + 5},
vm.Instruction{vm.EvalGreater, 0},
vm.Instruction{vm.Co... | go | {
"resource": ""
} |
q5473 | CompileToVM | train | func (b *blockEndIRInstruction) CompileToVM(p *irProgram) ([]vm.Instruction, error) {
block := p.blocks[b.blockId]
return []vm.Instruction{
vm.Instruction{vm.PopLoop, 0},
vm.Instruction{vm.AddLong, -1},
vm.Instruction{vm.EvalEqual, 0},
vm.Instruction{vm.CondJump, block.start},
vm.Instruction{vm.Jump, block.... | go | {
"resource": ""
} |
q5474 | RegisterDefinition | train | func (n *Namespace) RegisterDefinition(d Definition) error {
if curDef, ok := n.Definitions[d.AvroName()]; ok {
if !reflect.DeepEqual(curDef, d) {
return fmt.Errorf("Conflicting definitions for %v", d.AvroName())
}
return nil
}
n.Definitions[d.AvroName()] = d
for _, alias := range d.Aliases() {
if exist... | go | {
"resource": ""
} |
q5475 | decodeRecordDefinition | train | func (n *Namespace) decodeRecordDefinition(namespace string, schemaMap map[string]interface{}) (Definition, error) {
typeStr, err := getMapString(schemaMap, "type")
if err != nil {
return nil, err
}
if typeStr != "record" {
return nil, fmt.Errorf("Type of record must be 'record'")
}
name, err := getMapStrin... | go | {
"resource": ""
} |
q5476 | decodeEnumDefinition | train | func (n *Namespace) decodeEnumDefinition(namespace string, schemaMap map[string]interface{}) (Definition, error) {
typeStr, err := getMapString(schemaMap, "type")
if err != nil {
return nil, err
}
if typeStr != "enum" {
return nil, fmt.Errorf("Type of enum must be 'enum'")
}
if _, ok := schemaMap["namespace... | go | {
"resource": ""
} |
q5477 | decodeFixedDefinition | train | func (n *Namespace) decodeFixedDefinition(namespace string, schemaMap map[string]interface{}) (Definition, error) {
typeStr, err := getMapString(schemaMap, "type")
if err != nil {
return nil, err
}
if typeStr != "fixed" {
return nil, fmt.Errorf("Type of fixed must be 'fixed'")
}
if _, ok := schemaMap["names... | go | {
"resource": ""
} |
q5478 | parseAliases | train | func parseAliases(objectMap map[string]interface{}, namespace string) ([]QualifiedName, error) {
aliases, ok := objectMap["aliases"]
if !ok {
return make([]QualifiedName, 0), nil
}
aliasList, ok := aliases.([]interface{})
if !ok {
return nil, fmt.Errorf("Field aliases expected to be array, got %v", aliases)
... | go | {
"resource": ""
} |
q5479 | parseCmdLine | train | func parseCmdLine() config {
cfg := config{}
flag.StringVar(&cfg.packageName, "package", defaultPackageName, "Name of generated package.")
flag.BoolVar(&cfg.containers, "containers", defaultContainers, "Whether to generate container writer methods.")
flag.BoolVar(&cfg.shortUnions, "short-unions", defaultShortUnion... | go | {
"resource": ""
} |
q5480 | Compile | train | func Compile(writer, reader schema.AvroType) (*vm.Program, error) {
log("Compile()\n writer:\n %v\n---\nreader: %v\n---\n", writer, reader)
program := &irProgram{
methods: make(map[string]*irMethod),
errors: make([]string, 0),
}
program.main = newIRMethod("main", program)
err := program.main.compileType(wri... | go | {
"resource": ""
} |
q5481 | mergeMaps | train | func mergeMaps(m1, m2 map[string]interface{}) map[string]interface{} {
for k, v := range m2 {
if _, ok := m1[k]; !ok {
m1[k] = v
}
}
return m1
} | go | {
"resource": ""
} |
q5482 | UpdateMeta | train | func UpdateMeta(driver db.DB, metas []models.FeedMeta) error {
for _, meta := range metas {
meta.Hash = meta.LatestHash
meta.LastModifiedDate = meta.LatestLastModifiedDate
err := driver.UpsertFeedHash(meta)
if err != nil {
return fmt.Errorf("Failed to updte meta: %s, err: %s",
meta.URL, err)
}
}
ret... | go | {
"resource": ""
} |
q5483 | MakeNvdMetaURLs | train | func MakeNvdMetaURLs(year int, xml bool) (url []string) {
formatTemplate := ""
if xml {
// https://nvd.nist.gov/vuln/data-feeds#XML_FEED
formatTemplate = "https://nvd.nist.gov/feeds/xml/cve/nvdcve-2.0-%s.meta"
} else {
// https: //nvd.nist.gov/vuln/data-feeds#JSON_FEED
formatTemplate = "https://nvd.nist.gov/... | go | {
"resource": ""
} |
q5484 | NewRDB | train | func NewRDB(dbType, dbpath string, debugSQL bool) (driver *RDBDriver, locked bool, err error) {
driver = &RDBDriver{
name: dbType,
}
log.Debugf("Opening DB (%s).", driver.Name())
if locked, err = driver.OpenDB(dbType, dbpath, debugSQL); err != nil {
return nil, locked, err
}
log.Debugf("Migrating DB (%s).",... | go | {
"resource": ""
} |
q5485 | CloseDB | train | func (r *RDBDriver) CloseDB() (err error) {
if err = r.conn.Close(); err != nil {
log.Errorf("Failed to close DB. Type: %s. err: %s", r.name, err)
return
}
return
} | go | {
"resource": ""
} |
q5486 | getMatchingCpes | train | func (r *RDBDriver) getMatchingCpes(uri string) ([]models.Cpe, error) {
// parse wfn, get vendor, product
specified, err := naming.UnbindURI(uri)
if err != nil {
return nil, err
}
// sleect from cpe by vendor, product
cpes := []models.Cpe{}
err = r.conn.Where(&models.Cpe{
CpeBase: models.CpeBase{
CpeWFN:... | go | {
"resource": ""
} |
q5487 | GetCveIDsByCpeURI | train | func (r *RDBDriver) GetCveIDsByCpeURI(uri string) ([]string, error) {
filtered, err := r.getMatchingCpes(uri)
if err != nil {
return nil, err
}
cveIDs := make([]string, len(filtered))
// The cpes table is de-normalized. So the `First` is correct, don't be mislead.
for i, cpe := range filtered {
if cpe.JvnID... | go | {
"resource": ""
} |
q5488 | GetFetchedFeedMeta | train | func (r *RDBDriver) GetFetchedFeedMeta(url string) (*models.FeedMeta, error) {
meta := models.FeedMeta{}
m := &models.FeedMeta{
URL: url,
}
err := r.conn.Where(m).First(&meta).Error
if err != nil && err != gorm.ErrRecordNotFound {
return nil, err
}
return &meta, nil
} | go | {
"resource": ""
} |
q5489 | UpsertFeedHash | train | func (r *RDBDriver) UpsertFeedHash(mm models.FeedMeta) error {
meta := models.FeedMeta{}
m := &models.FeedMeta{
URL: mm.URL,
}
err := r.conn.Where(m).First(&meta).Error
if err != nil && err != gorm.ErrRecordNotFound {
return err
}
tx := r.conn.Begin()
if tx.Error != nil {
return tx.Error
}
if err == g... | go | {
"resource": ""
} |
q5490 | FetchFeedFiles | train | func FetchFeedFiles(reqs []FetchRequest) (results []FetchResult, err error) {
reqChan := make(chan FetchRequest, len(reqs))
resChan := make(chan FetchResult, len(reqs))
errChan := make(chan error, len(reqs))
defer close(reqChan)
defer close(resChan)
defer close(errChan)
for _, r := range reqs {
log.Infof("Fet... | go | {
"resource": ""
} |
q5491 | GenWorkers | train | func GenWorkers(num int) chan<- func() {
tasks := make(chan func())
for i := 0; i < num; i++ {
go func() {
for f := range tasks {
f()
}
}()
}
return tasks
} | go | {
"resource": ""
} |
q5492 | GetDefaultLogDir | train | func GetDefaultLogDir() string {
defaultLogDir := "/var/log/vuls"
if runtime.GOOS == "windows" {
defaultLogDir = filepath.Join(os.Getenv("APPDATA"), "vuls")
}
return defaultLogDir
} | go | {
"resource": ""
} |
q5493 | ParseCpeURI | train | func ParseCpeURI(uri string) (*models.CpeBase, error) {
var wfn common.WellFormedName
var err error
if strings.HasPrefix(uri, "cpe:/") {
val := strings.TrimPrefix(uri, "cpe:/")
if strings.Contains(val, "/") {
uri = "cpe:/" + strings.Replace(val, "/", `\/`, -1)
}
wfn, err = naming.UnbindURI(uri)
if err !... | go | {
"resource": ""
} |
q5494 | StringToFloat | train | func StringToFloat(str string) float64 {
if len(str) == 0 {
return 0
}
var f float64
var ignorableError error
if f, ignorableError = strconv.ParseFloat(str, 64); ignorableError != nil {
log.Errorf("Failed to cast CVSS score. score: %s, err; %s",
str,
ignorableError,
)
f = 0
}
return f
} | go | {
"resource": ""
} |
q5495 | NewDB | train | func NewDB(dbType, dbpath string, debugSQL bool) (DB, bool, error) {
switch dbType {
case dialectSqlite3, dialectMysql, dialectPostgreSQL:
return NewRDB(dbType, dbpath, debugSQL)
case dialectRedis:
return NewRedis(dbType, dbpath, debugSQL)
}
return nil, false, fmt.Errorf("Invalid database dialect, %s", dbType)... | go | {
"resource": ""
} |
q5496 | Validate | train | func (c *Config) Validate() bool {
if c.DBType == "sqlite3" {
if ok, _ := valid.IsFilePath(c.DBPath); !ok {
log.Errorf("SQLite3 DB path must be a *Absolute* file path. dbpath: %s", c.DBPath)
return false
}
}
if len(c.DumpPath) != 0 {
if ok, _ := valid.IsFilePath(c.DumpPath); !ok {
log.Errorf("JSON pa... | go | {
"resource": ""
} |
q5497 | Fetch | train | func Fetch(metas []models.FeedMeta) ([]Item, error) {
reqs := []fetcher.FetchRequest{}
for _, meta := range metas {
reqs = append(reqs, fetcher.FetchRequest{
URL: meta.URL,
})
}
results, err := fetcher.FetchFeedFiles(reqs)
if err != nil {
return nil,
fmt.Errorf("Failed to fetch. err: %s", err)
}
it... | go | {
"resource": ""
} |
q5498 | FetchConvert | train | func FetchConvert(metas []models.FeedMeta) (cves []models.CveDetail, err error) {
items, err := Fetch(metas)
if err != nil {
return nil, err
}
return convert(items)
} | go | {
"resource": ""
} |
q5499 | FetchConvert | train | func FetchConvert(metas []models.FeedMeta) (cves []models.CveDetail, err error) {
reqs := []fetcher.FetchRequest{}
for _, meta := range metas {
reqs = append(reqs, fetcher.FetchRequest{
URL: meta.URL,
GZIP: true,
})
}
results, err := fetcher.FetchFeedFiles(reqs)
if err != nil {
return nil,
fmt.Err... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.