input stringlengths 24 2.11k | output stringlengths 7 948 |
|---|---|
package lua
type Metatable struct {
IndexFunc Function
NewindexFunc Function
TostringFunc Function
GCFunc Function
}
func (this *Metatable) Index() Function {
return this.IndexFunc
}
func (this *Metatable) Newindex() Function {
return this.NewindexFunc
}
func (this *Metatable) GC() Fun... | {
return this.TostringFunc
} |
package external
import (
"github.com/Aptomi/aptomi/pkg/external/secrets"
"github.com/Aptomi/aptomi/pkg/external/users"
)
type Data struct {
UserLoader users.UserLoader
SecretLoader secrets.SecretLoader
}
func NewData(userLoader users.UserLoader, secretLoader secrets.SecretLoader) *Data | {
return &Data{
UserLoader: userLoader,
SecretLoader: secretLoader,
}
} |
package category
import (
"context"
"flag"
"fmt"
"io"
"github.com/vmware/govmomi/govc/cli"
"github.com/vmware/govmomi/govc/flags"
"github.com/vmware/govmomi/vapi/tags"
)
type ls struct {
*flags.ClientFlag
*flags.OutputFlag
}
func init() {
cli.Register("tags.category.ls", &ls{})
}
func (cmd *ls) Register(... | {
return `List all categories.
Examples:
govc tags.category.ls
govc tags.category.ls -json | jq .`
} |
package zk2topo
import (
"path"
"sort"
"golang.org/x/net/context"
)
func (zs *Server) ListDir(ctx context.Context, cell, dirPath string) ([]string, error) | {
conn, root, err := zs.connForCell(ctx, cell)
if err != nil {
return nil, err
}
zkPath := path.Join(root, dirPath)
children, _, err := conn.Children(ctx, zkPath)
if err != nil {
return nil, convertError(err)
}
sort.Strings(children)
return children, nil
} |
package export
import (
"bytes"
"database/sql"
"strings"
"github.com/pingcap/errors"
tcontext "github.com/pingcap/tidb/dumpling/context"
)
type TableDataIR interface {
Start(*tcontext.Context, *sql.Conn) error
Rows() SQLRowIter
Close() error
RawRows() *sql.Rows
}
type TableMeta interface {
DatabaseNam... | {
tps, err := rows.ColumnTypes()
if err != nil {
return nil, errors.Trace(err)
}
nms, err := rows.Columns()
if err != nil {
return nil, errors.Trace(err)
}
for i := range nms {
nms[i] = wrapBackTicks(nms[i])
}
return &tableMeta{
colTypes: tps,
selectedField: strings.Join(nms, ","),
selectedLen... |
package common
import (
"fmt"
v3 "github.com/rancher/rancher/pkg/generated/norman/management.cattle.io/v3"
"github.com/rancher/rancher/pkg/ref"
"github.com/sirupsen/logrus"
)
func GetRuleID(groupID string, ruleName string) string {
return fmt.Sprintf("%s_%s", groupID, ruleName)
}
func GetGroupID(namespace, nam... | {
return fmt.Sprintf("%s (ID: %s)", clusterDisplayName, clusterID)
} |
package iso20022
type RemittanceInformation8 struct {
RemittanceIdentification *Max35Text `xml:"RmtId,omitempty"`
Unstructured []*Max140Text `xml:"Ustrd,omitempty"`
Structured []*StructuredRemittanceInformation10 `xml:"Strd,omitempty"`
OriginalPaymentInformation *OriginalPaymentInformation6 `xml:"OrgnlPmtInf"... | {
r.OriginalPaymentInformation = new(OriginalPaymentInformation6)
return r.OriginalPaymentInformation
} |
package client_test
import (
"github.com/jdextraze/go-gesclient/client"
"testing"
)
func TestWrongExpectedVersion_Error(t *testing.T) {
if client.WrongExpectedVersion.Error() != "Wrong expected version" {
t.FailNow()
}
}
func TestStreamDeleted_Error(t *testing.T) {
if client.StreamDeleted.Error() != "Stream d... | {
if client.InvalidTransaction.Error() != "Invalid transaction" {
t.FailNow()
}
} |
package main
import (
"encoding/json"
"log"
"os"
"path/filepath"
"time"
)
type Player struct {
log *os.File
logTime time.Time
decoder *json.Decoder
dir string
offset time.Duration
}
func (p *Player) Reset() error {
n := p.Then()
p.logTime = logTime(n)
filename := logFileName(n)
if p.log != n... | {
var p Player
p.dir = dir
return &p
} |
package bigcache
func convertMBToBytes(value int) int {
return value * 1024 * 1024
}
func isPowerOfTwo(number int) bool {
return (number & (number - 1)) == 0
}
func max(a, b int) int | {
if a > b {
return a
}
return b
} |
package nodes
import (
"encoding/json"
"sync"
)
type Name struct {
TaxID string `json:"TaxID"`
Names []NameItem `json:"Names"`
}
type NameItem struct {
Name string `json:"Name"`
UniqueName string `json:"UniqueName"`
NameClass string `json:"NameClass"`
}
func (name Name) ToJSON() (string, error)... | {
var name Name
err := json.Unmarshal([]byte(s), &name)
return name, err
} |
package main
import (
"fmt"
"strings"
)
func WordCount(s string) map[string]int {
result := make(map[string]int)
for _, v := range strings.Fields(s) {
_, ok := result[v]
if ok == false {
result[v] = 0
}
result[v]++
}
return result
}
func map_operations() | {
m := make(map[string]int)
m["Answer"] = 42
fmt.Println("The value:", m["Answer"])
m["Answer"] = 48
fmt.Println("The value:", m["Answer"])
delete(m, "Answer")
fmt.Println("The value:", m["Answer"])
v, ok := m["Answer"]
fmt.Println("The value:", v, "Present?", ok)
} |
package methods
import (
"encoding/json"
"log"
"time"
"github.com/barnettzqg/journey/configuration"
"github.com/barnettzqg/journey/database"
"github.com/barnettzqg/journey/slug"
"github.com/barnettzqg/journey/structure"
)
var Blog *structure.Blog
var assetPath = []byte("/assets/")
func UpdateActiveTheme(... | {
navigation, err := json.Marshal(b.NavigationItems)
if err != nil {
return err
}
err = database.UpdateSettings(b.Title, b.Description, b.Logo, b.Cover, b.PostsPerPage, b.ActiveTheme, navigation, time.Now(), userId)
if err != nil {
return err
}
err = GenerateBlog()
if err != nil {
log.Panic("Error: couldn... |
package contentutil
import (
"context"
"github.com/containerd/containerd/content"
"github.com/containerd/containerd/errdefs"
"github.com/containerd/containerd/remotes"
"github.com/pkg/errors"
)
type pushingIngester struct {
p remotes.Pusher
}
func (i *pushingIngester) Writer(ctx context.Context, opts ...co... | {
return &pushingIngester{
p: p,
}
} |
package async
import (
"reflect"
)
func FilterParallel(data interface{}, routine Routine, callbacks ...Done) {
var routines []Routine
d := reflect.ValueOf(data)
for i := 0; i < d.Len(); i++ {
v := d.Index(i).Interface()
routines = append(routines, func(id int) Routine {
return func(done Done, args ..... | {
var (
routines []Routine
results []interface{}
)
d := reflect.ValueOf(data)
for i := 0; i < d.Len(); i++ {
v := d.Index(i).Interface()
routines = append(routines, func(id int) Routine {
return func(done Done, args ...interface{}) {
done = func(original Done) Done {
return func(err error, ar... |
package command
import (
"bytes"
"fmt"
"github.com/hashicorp/serf/serf"
"github.com/mitchellh/cli"
)
type VersionCommand struct {
Revision string
Version string
VersionPrerelease string
Ui cli.Ui
}
func (c *VersionCommand) Run(_ []string) int {
var versionString bytes.Bu... | {
return ""
} |
package bunyan
import "os"
type Sink interface {
Write(record Record) error
}
type funcSink struct {
write func(record Record) error
}
func (sink *funcSink) Write(record Record) error {
return sink.write(record)
}
func NilSink() Sink {
return SinkFunc(func(record Record) error {
return nil
})
}
fu... | {
return &funcSink{write}
} |
package models
import "time"
type KeyType struct {
ID int
Key string
Created time.Time
Expires bool
}
type Keys []KeyType
func (f Keys) Len() int {
return len(f)
}
func (f Keys) Swap(i, j int) {
f[i], f[j] = f[j], f[i]
}
func (f Keys) Less(i, j int) bool | {
return f[i].ID < f[j].ID
} |
package container
import (
"github.com/e154/smart-home/models"
"github.com/e154/smart-home/system/backup"
)
func NewBackupConfig(cfg *models.AppConfig) *backup.BackupConfig | {
return &backup.BackupConfig{
Path: cfg.SnapshotDir,
PgUser: cfg.PgUser,
PgPass: cfg.PgPass,
PgHost: cfg.PgHost,
PgName: cfg.PgName,
PgPort: cfg.PgPort,
}
} |
package master
import ()
type frame struct {
job *job
slaveName string
frame int
data []byte
progress byte
completed bool
}
func NewFrame(job *job, fr int) *frame {
return &frame{
job: job,
slaveName: "",
frame: fr,
data: nil,
progress: 0,
completed: false,
}
}... | {
f.completed = completed
if completed {
f.SetProgress(100)
}
} |
package dfa
import (
"fmt"
"unicode"
)
func eachRangeInCharClass(name string, visit func(lo, hi rune)) error {
table := unicode.Categories[name]
if table == nil {
table = unicode.Scripts[name]
if table == nil {
return fmt.Errorf("character class %s not exists", name)
}
}
for _, xr := range table.R16... | {
ms := []*M{}
err = eachRangeInCharClass(name, func(lo, hi rune) {
ms = append(ms, Between(lo, hi))
})
if err != nil {
return nil, err
}
m, err = orMany(ms)
if err != nil {
return nil, err
}
return m.minimize()
} |
package mcore
import (
"log"
)
type StringKeyValueMap map[string]string
func NewStringKeyValueMap() StringKeyValueMap {
return make(map[string]string)
}
func (c StringKeyValueMap) Put(key, value string) {
c[key] = value
}
func (c StringKeyValueMap) IsContain(key string) bool {
_, ok := c[key]
return ok
}
fu... | {
return String(c.GetString(key)).ToBool()
} |
package format
import (
"reflect"
"strconv"
)
func Any(value interface{}) string {
return formatAtom(reflect.ValueOf(value))
}
func formatAtom(v reflect.Value) string | {
switch v.Kind() {
case reflect.Invalid:
return "invalid"
case reflect.Int, reflect.Int8, reflect.Int16,
reflect.Int32, reflect.Int64:
return strconv.FormatInt(v.Int(), 10)
case reflect.Uint, reflect.Uint8, reflect.Uint16,
reflect.Uint32, reflect.Uint64, reflect.Uintptr:
return strconv.FormatUint(v.Uint(... |
package bigquery
import (
"fmt"
"github.com/viant/endly"
"github.com/viant/endly/system/cloud/gcp"
"google.golang.org/api/bigquery/v2"
)
var clientKey = (*CtxClient)(nil)
type CtxClient struct {
*gcp.AbstractClient
service *bigquery.Service
}
func (s *CtxClient) SetService(service interface{}) error {
var o... | {
client := &CtxClient{
AbstractClient: &gcp.AbstractClient{},
}
err := gcp.GetClient(context, bigquery.New, clientKey, &client, bigquery.CloudPlatformScope, bigquery.BigqueryScope, bigquery.BigqueryInsertdataScope)
return client, err
} |
package iotcentral
import "github.com/Azure/azure-sdk-for-go/version"
func Version() string {
return version.Number
}
func UserAgent() string | {
return "Azure-SDK-For-Go/" + Version() + " iotcentral/2021-06-01"
} |
package resources
import (
"sort"
"encoding/json"
"github.com/mitchellh/mapstructure"
)
type AWSServerlessApplication_Location struct {
String *string
ApplicationLocation *AWSServerlessApplication_ApplicationLocation
}
func (r AWSServerlessApplication_Location) value() interface{} {
if r.String != nil {
... | {
return json.Marshal(r.value())
} |
package repository
import (
"strings"
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/modules/cache"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/setting"
)
func CacheRef(repo *models.Repository, gitRepo *git.Repository, fullRefName string) error {
if !setting.CacheService.LastCommit.Ena... | {
if strings.HasPrefix(fullRefName, git.TagPrefix) {
return fullRefName[len(git.TagPrefix):]
} else if strings.HasPrefix(fullRefName, git.BranchPrefix) {
return fullRefName[len(git.BranchPrefix):]
}
return ""
} |
package sortedmap
import (
"testing"
"github.com/umpc/go-sortedmap/asc"
)
func insertRecord(b *testing.B) {
records := randRecords(1)
sm := New(0, asc.Time)
b.ResetTimer()
for i := 0; i < b.N; i++ {
sm.Insert(records[0].Key, records[0].Val)
b.StopTimer()
records = randRecords(1)
sm = New(0, asc.Time)... | {
batchInsertRecords(b, 100)
} |
package block
type NoopLeaseManager struct{}
func (n *NoopLeaseManager) UnregisterLeaser(leaser Leaser) error {
return nil
}
func (n *NoopLeaseManager) OpenLease(
leaser Leaser,
descriptor LeaseDescriptor,
state LeaseState,
) error {
return nil
}
func (n *NoopLeaseManager) OpenLatestLease(
leaser Leaser,
... | {
return nil
} |
package main
import (
"github.com/codegangsta/martini-contrib/render"
"github.com/luan/godo/godo"
"net/http"
)
type ProjectsController struct{}
func (c *ProjectsController) List(r render.Render) {
projects, _ := godo.NewProjectManager().FindAllWithTasks()
r.HTML(200, "projects", projects)
}
func (c *Project... | {
p := godo.NewProject(req.FormValue("name"))
godo.NewProjectManager().Add(&p)
r.Redirect("/projects", 301)
} |
package parsex
import (
"errors"
"fmt"
"io"
)
type ParsexError struct {
Pos int
Message string
}
func (err ParsexError) Error() string {
return fmt.Sprintf("pos %d :\n%s",
err.Pos, err.Message)
}
type ParsexState interface {
Next(pred func(int, interface{}) (interface{}, error)) (x interface{}, err err... | {
return &StateInMemory{buffer, 0}
} |
package main
import (
"fmt"
"github.com/ian-kent/go-log/log"
"github.com/ian-kent/gotcha/http"
"strconv"
)
func pkgindex(session *http.Session) {
if _, ok := session.Stash["repo"]; !ok {
session.RenderNotFound()
return
}
repo := session.Stash["repo"].(string)
for fname, _ := range indexes {
if _, ok... | {
if len(pkgspace.Packages) > 0 {
latest := pkgspace.Packages[0]
if len(latest.Version) == 0 {
latest.Version = "undef"
}
session.Response.WriteText(fmt.Sprintf("%-40s %-10s %s\n", pkgspace.FullName(), latest.Version, latest.Package.AuthorURL()))
}
if len(pkgspace.Children) > 0 {
for _, ps := range pkg... |
package main
import (
"fmt"
"github.com/mrcsparker/ifin/service"
)
func main() {
fmt.Println(welcome())
controller := service.Flow{}
fmt.Println(controller.GetAboutInfo())
}
func welcome() string | {
return "[ifin]"
} |
package eventbreakpoints
import (
"context"
"github.com/chromedp/cdproto/cdp"
)
type SetInstrumentationBreakpointParams struct {
EventName string `json:"eventName"`
}
func (p *SetInstrumentationBreakpointParams) Do(ctx context.Context) (err error) {
return cdp.Execute(ctx, CommandSetInstrumentatio... | {
return &SetInstrumentationBreakpointParams{
EventName: eventName,
}
} |
package pointer
import "time"
func DefaultBool(value *bool, defaultValue bool) *bool {
if value == nil {
return &defaultValue
}
return value
}
func DefaultDuration(value *time.Duration, defaultValue time.Duration) *time.Duration {
if value == nil {
return &defaultValue
}
return value
}
func DefaultFloat64... | {
if value == nil {
return &defaultValue
}
return value
} |
package lease
type block struct {
leaseName string
unblock chan struct{}
abort <-chan struct{}
}
func (b block) invoke(ch chan<- block) error {
for {
select {
case <-b.abort:
return errStopped
case ch <- b:
ch = nil
case <-b.unblock:
return nil
}
}
}
type blocks map[string][]chan ... | {
unblocks := b[leaseName]
delete(b, leaseName)
for _, unblock := range unblocks {
close(unblock)
}
} |
package grace
import "net/http"
type ServeMux struct {
http.ServeMux
}
func NewServeMux() *ServeMux { return &ServeMux{*http.NewServeMux()} }
var DefaultServeMux = NewServeMux()
func (sm *ServeMux) HandleFunc(pattern string, handler func(http.ResponseWriter, *http.Request)) | {
sm.Handle(pattern, HandlerFunc(handler))
} |
package remotestate
import (
"context"
"github.com/r3labs/terraform/backend"
"github.com/r3labs/terraform/helper/schema"
"github.com/r3labs/terraform/state"
"github.com/r3labs/terraform/state/remote"
"github.com/r3labs/terraform/terraform"
)
type Backend struct {
*schema.Backend
ConfigureFunc func(ctx ... | {
if b.client == nil {
panic("nil remote client")
}
if name != backend.DefaultStateName {
return nil, backend.ErrNamedStatesNotSupported
}
s := &remote.State{Client: b.client}
return s, nil
} |
package rotaryLogger
import (
"fmt"
"io"
"log"
"os"
"strconv"
"time"
)
var Logger *log.Logger
var file os.File
func StartLogger(logLocation string) {
file, err := os.OpenFile(logLocation+"0.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
if err != nil {
log.Fatal("Failed to open Logger file", er... | {
logRotator(logAmount, logLocation)
StartLogger(logLocation)
ticker := time.NewTicker(rotationPeriod)
go func() {
for _ = range ticker.C {
Logger.Println("Rotating Logs")
Logger = log.New(os.Stdout,
"",
log.Ldate|log.Ltime|log.Lshortfile)
logRotator(logAmount, logLocation)
StartLogger(l... |
package s0132
import (
"github.com/peterstace/project-euler/number"
)
func Answer() interface{} {
return SumPrimeFactors(40, 10e9)
}
func repunit(k, m int) int {
if k == 1 {
return 1
}
if k%2 == 0 {
half := repunit(k/2, m)
return (tenPow(k/2, m)*half + half) % m
} else {
return (10*repunit(k-1, m) +... | {
var factorsFound int
var sum int
nthPrime := number.MakeSieveBackedNthPrime()
for i := 0; factorsFound < numFactors; i++ {
p := nthPrime(i)
if repunit(k, p) == 0 {
factorsFound++
sum += p
}
}
return sum
} |
package api
import (
"context"
"fmt"
"github.com/google/gapid/core/data/id"
"github.com/google/gapid/core/image"
"github.com/google/gapid/gapil/constset"
)
type API interface {
Name() string
Index() uint8
ID() ID
ConstantSets() *constset.Pack
GetFramebufferAttachmentInfo(
ctx context.Context,
afte... | {
return apis[id]
} |
package vcl
import (
. "github.com/ying32/govcl/vcl/api"
. "github.com/ying32/govcl/vcl/types"
)
type (
NSObject uintptr
NSWindow uintptr
NSURL uintptr
)
func (f *TForm) PlatformWindow() NSWindow {
r, _, _ := NSWindow_FromForm.Call(f.instance)
return NSWindow(r)
}
func (n NSWindow) TitleVisibility() ... | {
return NSObject(h)
} |
package main
import (
"fmt"
)
func main() {
args := []int{5, 2, 6, 1}
fmt.Println(countSmaller(args))
}
func countSmaller(nums []int) []int | {
var nums2 []int
for i, numb := range nums {
timeCount := 0
for ii := i; ii < len(nums); ii++ {
if nums[ii] < numb {
timeCount = timeCount + 1
}
}
nums2 = append(nums2, timeCount)
}
return nums2
} |
package engine
type Novel struct {
Name string
LastUpdateTime string
Author string
MenuURL string
IconURL string
NewestLastChapterName string
Description string
Menus []*Menu
Ch... | {
return &Menu{name, url}
} |
package block
type NoopLeaseManager struct{}
func (n *NoopLeaseManager) RegisterLeaser(leaser Leaser) error {
return nil
}
func (n *NoopLeaseManager) UnregisterLeaser(leaser Leaser) error {
return nil
}
func (n *NoopLeaseManager) OpenLatestLease(
leaser Leaser,
descriptor LeaseDescriptor,
) (LeaseState, erro... | {
return nil
} |
package config
import (
"encoding/json"
"os"
)
type Config struct {
BindAddress string `json:"bindAddress"`
ImageDirectory string `json:"imageDirectory"`
DbProtocol string `json:"dbProtocol"`
DbAddress string `json:"dbAddress"`
DbName string `json:"dbName"`
DbUser string `json:"... | {
file, openErr := os.Open(path)
if openErr != nil {
return nil, openErr
}
defer file.Close()
decoder := json.NewDecoder(file)
config := Config{}
decodeErr := decoder.Decode(&config)
return &config, decodeErr
} |
package render
import (
"fmt"
"net/http"
)
type Redirect struct {
Code int
Request *http.Request
Location string
}
func (r Redirect) Render(w http.ResponseWriter) error | {
if r.Code < 300 || r.Code > 308 {
panic(fmt.Sprintf("Cannot redirect with status code %d", r.Code))
}
http.Redirect(w, r.Request, r.Location, r.Code)
return nil
} |
package main
import (
"os"
"fmt"
"bufio"
"encoding/hex"
)
func check(e error) {
if e != nil {
fmt.Printf("Error: %s\n", e.Error())
os.Exit(0)
}
}
func get_hex_data(filename string) [][]byte {
file, err := os.Open(filename)
check(err)
var data [][]byte
scan := bufio.NewScanner... | {
var chunks [][]byte
for i:=0; i<len(data); i=i+size {
chunks = append(chunks, data[i:i+size])
}
return chunks
} |
package routetemplate
import (
"fmt"
"reflect"
)
var routeTemplates []RouteTemplate
func Add(template string) (err error) {
routeTemplate, _ := Parse(template)
routeTemplates = append(routeTemplates, routeTemplate)
return nil
}
func GetMatchedTemplateString(url string) (template string, err error) {
template ... | {
template = ""
for _, value := range routeTemplates {
wasMatched, _ := IsMatch(url, value)
if wasMatched {
template = value.TemplatePath
break
}
}
return template, nil
} |
package models
import (
"github.com/go-swagger/go-swagger/errors"
"github.com/go-swagger/go-swagger/httpkit/validate"
"github.com/go-swagger/go-swagger/strfmt"
)
type Ticket struct {
EventID string `json:"event_id,omitempty"`
Num int32 `json:"num,omitempty"`
}
func (m *Ticket) Validate(formats strfmt.Reg... | {
if err := validate.Required("num", "body", int32(m.Num)); err != nil {
return err
}
return nil
} |
package cgzip
import "C"
import (
"hash"
"unsafe"
)
type adler32Hash struct {
adler C.uLong
}
func NewAdler32() hash.Hash32 {
a := &adler32Hash{}
a.Reset()
return a
}
func (a *adler32Hash) Write(p []byte) (n int, err error) {
if len(p) > 0 {
a.adler = C.adler32(a.adler, (*C.Bytef)(unsafe.Pointer(&p[0]... | {
s := a.Sum32()
b = append(b, byte(s>>24))
b = append(b, byte(s>>16))
b = append(b, byte(s>>8))
b = append(b, byte(s))
return b
} |
package database
import (
"github.com/oracle/oci-go-sdk/common"
"net/http"
)
type TerminateDbSystemRequest struct {
DbSystemId *string `mandatory:"true" contributesTo:"path" name:"dbSystemId"`
IfMatch *string `mandatory:"false" contributesTo:"header" name:"if-match"`
OpcRequestId *string `mandatory:"false" c... | {
return response.RawResponse
} |
package routes
import (
"k8s.io/kubernetes/pkg/genericapiserver/server/mux"
"github.com/emicklei/go-restful/swagger"
)
type Swagger struct {
Config *swagger.Config
}
func (s Swagger) Install(c *mux.APIContainer) | {
s.Config.WebServices = c.RegisteredWebServices()
swagger.RegisterSwaggerService(*s.Config, c.Container)
} |
package store
import (
"github.com/docker/docker/pkg/plugins"
)
func FindWithCapability(capability string) ([]CompatPlugin, error) {
pl, err := plugins.GetAll(capability)
if err != nil {
return nil, err
}
result := make([]CompatPlugin, len(pl))
for i, p := range pl {
result[i] = p
}
return result, nil
}
... | {
return plugins.Get(name, capability)
} |
package notmain
import (
"testing"
"github.com/letsencrypt/boulder/test"
)
func TestLineValidAccepts(t *testing.T) {
err := lineValid("2020-07-06T18:07:43.109389+00:00 70877f679c72 datacenter 6 boulder-wfe[1595]: kKG6cwA Caught SIGTERM")
test.AssertNotError(t, err, "errored on valid checksum")
}
func TestLineVa... | {
err := lineValid("2020-07-06T18:07:43.109389+00:00 70877f679c72 datacenter 6 boulder-wfe[1595]: xxxx Caught SIGTERM")
test.AssertError(t, err, "didn't error on invalid checksum")
test.AssertErrorIs(t, err, errInvalidChecksum)
} |
package figure
import (
"fmt"
"log"
"net/http"
"strconv"
"strings"
)
const signature = "flf2"
const reverseFlag = "1"
var charDelimiters = [3]string{"@", "#", "$"}
var hardblanksBlacklist = [2]byte{'a', '2'}
func getFile(name string) (file http.File) {
filePath := fmt.Sprintf("%s.flf", name)
file, err ... | {
datum := strings.Fields(metadata)[0]
hardblank := datum[len(datum)-1]
if hardblank == hardblanksBlacklist[0] || hardblank == hardblanksBlacklist[1] {
return ' '
} else {
return hardblank
}
} |
package lib2048
import (
"fmt"
"time"
)
type Direction int
const layout = "15:04:05.12"
const (
Up Direction = iota + 1
Left
Down
Right
)
type Move struct {
Time time.Time
Direction Direction
}
func NewMove(dir Direction) *Move {
return &Move{time.Now(), dir}
}
func (m *Move) String() string | {
var moveString string
switch m.Direction {
case Up:
moveString = "Up"
case Down:
moveString = "Down"
case Left:
moveString = "Left"
case Right:
moveString = "Right"
}
return fmt.Sprintf("'%s': %s", m.Time.Format(layout), moveString)
} |
package azure
import (
"errors"
"fmt"
"os"
v1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/uuid"
"k8s.io/kubernetes/test/e2e/framework"
"k8s.io/legacy-cloud-providers/azure"
)
func init() {
framework.RegisterProvider("azure", newProvider)
}
type Provider struct {
framework.NullProvider
azureClou... | {
if framework.TestContext.CloudConfig.ConfigFile == "" {
return nil, fmt.Errorf("config-file must be specified for Azure")
}
config, err := os.Open(framework.TestContext.CloudConfig.ConfigFile)
if err != nil {
framework.Logf("Couldn't open cloud provider configuration %s: %#v",
framework.TestContext.CloudCo... |
package serviceaccess_test
import (
"github.com/cloudfoundry/cli/cf/i18n"
"github.com/cloudfoundry/cli/cf/i18n/detection"
"github.com/cloudfoundry/cli/testhelpers/configuration"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
"testing"
)
func TestServiceAccess(t *testing.T) | {
config := configuration.NewRepositoryWithDefaults()
i18n.T = i18n.Init(config, &detection.JibberJabberDetector{})
RegisterFailHandler(Fail)
RunSpecs(t, "Service Access Suite")
} |
package syscall
func setTimespec(sec, nsec int64) Timespec {
return Timespec{Sec: sec, Nsec: nsec}
}
func setTimeval(sec, usec int64) Timeval {
return Timeval{Sec: sec, Usec: usec}
}
func (iov *Iovec) SetLen(length int) {
iov.Len = uint64(length)
}
func (msghdr *Msghdr) SetControllen(length int) {
msghdr.Cont... | {
k.Ident = uint64(fd)
k.Filter = int16(mode)
k.Flags = uint16(flags)
} |
package common
import (
"encoding/binary"
"sort"
)
type Uint64Slice []uint64
func (p Uint64Slice) Len() int { return len(p) }
func (p Uint64Slice) Less(i, j int) bool { return p[i] < p[j] }
func (p Uint64Slice) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
func (p Uint64Slice) Sort() { s... | {
return sort.Search(len(a), func(i int) bool { return a[i] >= x })
} |
package nom
import (
"encoding/gob"
"fmt"
)
const (
PortFlood UID = "Ports.PortBcast"
PortAll UID = "Ports.PortAll"
)
type PacketIn struct {
Node UID
InPort UID
BufferID PacketBufferID
Packet Packet
}
func (in PacketIn) String() string {
return fmt.Sprintf("packet in on switch %s port %s", in.N... | {
return MACAddr{p[6], p[7], p[8], p[9], p[10], p[11]}
} |
package testlib
import (
"os"
"testing"
"github.com/stretchr/testify/require"
)
func Mktmp(tb testing.TB) string | {
tb.Helper()
folder := tb.TempDir()
current, err := os.Getwd()
require.NoError(tb, err)
require.NoError(tb, os.Chdir(folder))
tb.Cleanup(func() {
require.NoError(tb, os.Chdir(current))
})
return folder
} |
package dml_test
import (
"encoding/xml"
"testing"
"baliance.com/gooxml/schema/soo/dml"
)
func TestCT_TablePartStyleConstructor(t *testing.T) {
v := dml.NewCT_TablePartStyle()
if v == nil {
t.Errorf("dml.NewCT_TablePartStyle must return a non-nil value")
}
if err := v.Validate(); err != nil {
t.Errorf("ne... | {
v := dml.NewCT_TablePartStyle()
buf, _ := xml.Marshal(v)
v2 := dml.NewCT_TablePartStyle()
xml.Unmarshal(buf, v2)
} |
package migrations
import "xorm.io/xorm"
func addEmailHashTable(x *xorm.Engine) error | {
type EmailHash struct {
Hash string `xorm:"pk varchar(32)"`
Email string `xorm:"UNIQUE NOT NULL"`
}
return x.Sync2(new(EmailHash))
} |
package xmlkey
import (
"bytes"
"encoding/base64"
"encoding/xml"
"math/big"
)
type (
keyXML struct {
XMLName xml.Name `xml:"RSAKeyValue"`
publicKeyXML
privateKeyXML
}
publicKeyXML struct {
Modulus, Exponent *bigInt
}
privateKeyXML struct {
P, Q, DP, DQ, D, InverseQ *bigInt
}
bigInt struct{ *big... | {
for _, bi := range bis {
if bi == nil || bi.IsEmpty() {
return false
}
}
return true
} |
package blanket_emulator
import (
"fmt"
)
type Event interface {
Hash() uint64
Inspect() string
}
type ReturnEvent uint64
type ReadEvent uint64
type WriteEvent struct {
Addr uint64
Value uint64
}
type SyscallEvent uint64
type InvalidInstructionEvent uint64
func (addr ReadEvent) Hash() uint64 {
return ReadEve... | {
return WriteEventHash(s.Addr, s.Value)
} |
package cli
import "github.com/scaleway/scaleway-cli/pkg/commands"
var cmdRm = &Command{
Exec: runRm,
UsageLine: "rm [OPTIONS] SERVER [SERVER...]",
Description: "Remove one or more servers",
Help: "Remove one or more servers.",
Examples: `
$ scw rm myserver
$ scw rm -f myserver
$ scw ... | {
if rmHelp {
return cmd.PrintUsage()
}
if len(rawArgs) < 1 {
return cmd.PrintShortUsage()
}
args := commands.RmArgs{
Servers: rawArgs,
Force: rmForce,
}
ctx := cmd.GetContext(rawArgs)
return commands.RunRm(ctx, args)
} |
package srcobj
import (
"fmt"
"io"
)
type DrawChar string
func (dc DrawChar) Dump(w io.Writer) error | {
_, err := fmt.Fprintf(w, `"%s"`, string(dc))
return err
} |
package gen
import (
"regexp"
"strings"
)
func ReplaceSearchCallback(code []byte, modelName string) []byte {
rSearchCallback, _ := regexp.Compile("SearchCallback")
result := rSearchCallback.ReplaceAll(code, []byte("SearchCallback"+strings.Title(modelName)))
return result
}
func RemovePackage(code []byte) []by... | {
rICollections, _ := regexp.Compile("(import \"sort\")")
result := rICollections.ReplaceAll(code, []byte(""))
return result
} |
package main
import (
"fmt"
"github.com/jackytck/projecteuler/tools"
)
func isSumOfTwoAbundant(n int, a []bool) bool {
var ret bool
for i := 1; i < n; i++ {
if a[i] && a[n-i] {
ret = true
break
}
}
return ret
}
func solve() int {
var sum int
ab := make([]bool, 28124)
for i := 12; i <= 28123; i+... | {
return tools.SumDivisors(n) > n
} |
package middleware
import (
"github.com/drone/drone/shared/model"
"github.com/zenazn/goji/web"
)
func UserToC(c *web.C, user *model.User) {
c.Env["user"] = user
}
func RoleToC(c *web.C, role *model.Perm) {
c.Env["role"] = role
}
func ToUser(c *web.C) *model.User {
var v = c.Env["user"]
if v == nil ... | {
c.Env["repo"] = repo
} |
package ast
import "monkey/token"
type StringLiteral struct {
Token token.Token
Value string
}
func (s *StringLiteral) expressionNode() {}
func (s *StringLiteral) TokenLiteral() string { return s.Token.Literal }
func (s *StringLiteral) String() string { return s.Token.Literal }
type InterpolatedString ... | { return is.Token.Literal } |
package handlers
import (
"github.com/bbiskup/edify-web/defs"
"html/template"
"log"
"net/http"
)
var indexTemplates *template.Template
func init() {
indexTemplates = template.Must(template.ParseFiles(
defs.TemplatePaths("layout.html", "navbar.html", "index.html")...,
))
}
func Index(w http.ResponseWriter,... | {
err := indexTemplates.ExecuteTemplate(w, "layout", nil)
if err != nil {
log.Printf("Error executing template: %s", err)
}
} |
package tristate
type StateValue int
const (
TRISTATE_SUCCESS StateValue = iota
TRISTATE_FAILRUE
TRISTATE_UNKNOWN
)
type TriState struct {
State StateValue
Err error
}
func NewSuccess() *TriState {
return nil
}
func NewUnknown(err error) *TriState {
if err == nil {
panic("error not set")
}
return &TriSt... | {
return state == nil || state.State == TRISTATE_SUCCESS
} |
package v1beta2
import (
v1beta2 "github.com/enmasseproject/enmasse/pkg/apis/admin/v1beta2"
"github.com/enmasseproject/enmasse/pkg/client/clientset/versioned/scheme"
rest "k8s.io/client-go/rest"
)
type AdminV1beta2Interface interface {
RESTClient() rest.Interface
AddressPlansGetter
AddressSpacePlansGetter
}
t... | {
config := *c
if err := setConfigDefaults(&config); err != nil {
return nil, err
}
client, err := rest.RESTClientFor(&config)
if err != nil {
return nil, err
}
return &AdminV1beta2Client{client}, nil
} |
package http
import (
"go-common/app/admin/main/app/model/language"
bm "go-common/library/net/http/blademaster"
)
func languages(c *bm.Context) {
c.JSON(langSvc.Languages(c))
}
func addOrup(c *bm.Context) {
var (
err error
v = &language.Param{}
)
if err = c.Bind(v); err != nil {
return
}
if v.ID... | {
v := &language.Param{}
if err := c.Bind(v); err != nil {
return
}
c.JSON(langSvc.LangByID(c, v.ID))
} |
package log
import (
"os"
"testing"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/assert"
)
func TestLogFile(t *testing.T) {
fileLogWrite := NewFileWriter()
require.NotNil(t, fileLogWrite)
t.Cleanup(func() {
err := fileLogWrite.Close()
assert.NoError(t, err)
err = os.Remove(file... | {
_, err := w.Write([]byte(line))
return err
} |
package udp
import (
"encoding/binary"
"github.com/davyxu/cellnet/codec"
)
const (
MTU = 1472
packetLen = 2
MsgIDLen = 2
HeaderSize = MsgIDLen + MsgIDLen
)
func RecvPacket(pktData []byte) (msg interface{}, err error) | {
if len(pktData) < packetLen {
return nil, nil
}
datasize := binary.LittleEndian.Uint16(pktData)
if int(datasize) != len(pktData) || datasize > MTU {
return nil, nil
}
msgid := binary.LittleEndian.Uint16(pktData[packetLen:])
msgData := pktData[HeaderSize:]
msg, _, err = codec.DecodeMessage(int(msgid)... |
package packer
import (
"bytes"
"fmt"
)
var GitCommit string
const Version = "0.5.3"
const VersionPrerelease = "dev"
type versionCommand byte
func (versionCommand) Help() string {
return `usage: packer version
Outputs the version of Packer that is running. There are no additional
command-line flags for ... | {
var versionString bytes.Buffer
fmt.Fprintf(&versionString, "Packer v%s", Version)
if VersionPrerelease != "" {
fmt.Fprintf(&versionString, ".%s", VersionPrerelease)
if GitCommit != "" {
fmt.Fprintf(&versionString, " (%s)", GitCommit)
}
}
return versionString.String()
} |
package learn
import (
"fmt"
)
type List struct {
Data interface{}
Nextnode *List
}
func myPrint(t interface{}) {
fmt.Println(t)
}
func (l *List) ListLength() int {
var i int = 0
n := l
for n.Nextnode != nil {
i++
n = n.Nextnode
}
return i + 1
}
func (l *List) GetEle(i int) (ele interface{}) {
... | {
var s List
if i < 0 || i > l.ListLength() {
return false
}
s.Data = ele
p := l
j := 1
for j < i && p != nil {
j++
p = p.Nextnode
}
if p != nil && j <= i {
s.Nextnode = p.Nextnode
p.Nextnode = &s
} else {
return false
}
return true
} |
package vhosts
import (
"net/http"
"strings"
"sync"
)
type VirtualHosts struct {
vhosts map[string]http.Handler
mu sync.RWMutex
}
func NewVirtualHosts(vhosts map[string]http.Handler) *VirtualHosts {
v := &VirtualHosts{}
for hosts, h := range vhosts {
for _, host := range strings.Split(hosts, " ") {
i... | {
v.mu.RLock()
defer v.mu.RUnlock()
if v.vhosts != nil {
if handler, ok := v.vhosts[r.Host]; ok && handler != nil {
handler.ServeHTTP(w, r)
return
}
}
http.NotFound(w, r)
} |
package bytealg
const MaxBruteForce = 0
func Index(a, b []byte) int {
panic("unimplemented")
}
func Cutover(n int) int {
panic("unimplemented")
}
func IndexString(s, substr string) int | {
n := len(substr)
c0 := substr[0]
c1 := substr[1]
i := 0
t := len(s) - n + 1
fails := 0
for i < t {
if s[i] != c0 {
o := IndexByteString(s[i:t], c0)
if o < 0 {
return -1
}
i += o
}
if s[i+1] == c1 && s[i:i+n] == substr {
return i
}
i++
fails++
if fails >= 4+i>>4 && i < t {
j ... |
package util
import (
"strings"
"github.com/spf13/viper"
)
const EnvPrefix = "GSD"
func InitViper(v *viper.Viper, subViperName string) {
v.SetEnvKeyReplacer(strings.NewReplacer("-", "_"))
if subViperName != "" {
v.SetEnvPrefix(EnvPrefix + "_" + strings.ToUpper(subViperName))
} else {
v.SetEnvPrefix(E... | {
n := v.Sub(key)
if n == nil {
n = viper.New()
}
InitViper(n, key)
return n
} |
package blobstoredbstatesnapshotio
import (
"fmt"
"golang.org/x/net/context"
"github.com/nyaxt/otaru/metadata"
)
func generateBlobpath() string {
return fmt.Sprintf("%s_SimpleSSLocator", metadata.INodeDBSnapshotBlobpathPrefix)
}
var simplesslocatorTxID int64
type SimpleSSLocator struct{}
func (SimpleSSLocato... | {
return generateBlobpath()
} |
package cli
import (
"errors"
"fmt"
"log"
"github.com/alexyer/ghost/client"
)
func ObtainClient(host string, port int) (*client.GhostClient, error) {
addr := fmt.Sprintf("%s:%d", host, port)
return connect(addr, "tcp")
}
func connect(addr, network string) (*client.GhostClient, error) {
c := client.New(&... | {
return connect(socket, "unix")
} |
package test
import "github.com/tidepool-org/platform/test"
func NewAccessToken() string {
return test.RandomStringFromRangeAndCharset(256, 256, test.CharsetAlphaNumeric)
}
func NewSessionToken() string {
return test.RandomStringFromRangeAndCharset(256, 256, test.CharsetAlphaNumeric)
}
func NewRestrictedToken()... | {
return test.RandomStringFromRangeAndCharset(128, 128, test.CharsetAlphaNumeric)
} |
package account
import (
"flag"
"golang.org/x/net/context"
"github.com/vmware/govmomi/govc/cli"
)
type update struct {
*AccountFlag
}
func init() {
cli.Register("host.account.update", &update{})
}
func (cmd *update) Process(ctx context.Context) error {
if err := cmd.AccountFlag.Process(ctx); err != nil {
... | {
cmd.AccountFlag, ctx = newAccountFlag(ctx)
cmd.AccountFlag.Register(ctx, f)
} |
package byteorder
import (
"encoding/binary"
"net"
"testing"
. "gopkg.in/check.v1"
)
func Test(t *testing.T) {
TestingT(t)
}
type ByteorderSuite struct{}
var _ = Suite(&ByteorderSuite{})
func (b *ByteorderSuite) TestHostToNetwork(c *C) {
switch Native {
case binary.LittleEndian:
c.Assert(HostToNetwork... | {
c.Assert(Native, NotNil)
} |
package core
import (
"github.com/oracle/oci-go-sdk/common"
"net/http"
)
type UpdateDedicatedVmHostRequest struct {
DedicatedVmHostId *string `mandatory:"true" contributesTo:"path" name:"dedicatedVmHostId"`
UpdateDedicatedVmHostDetails `contributesTo:"body"`
IfMatch *string `mandatory:"false" contributesTo:"... | {
return common.PointerString(response)
} |
package throttler
import (
"vitess.io/vitess/go/sync2"
)
type MaxRateModule struct {
maxRate sync2.AtomicInt64
rateUpdateChan chan<- struct{}
}
func NewMaxRateModule(maxRate int64) *MaxRateModule {
return &MaxRateModule{
maxRate: sync2.NewAtomicInt64(maxRate),
}
}
func (m *MaxRateModule) Start(ra... | {
return m.maxRate.Get()
} |
package main
import (
"fmt"
"os"
"time"
"github.com/go-redis/redis"
"github.com/jasonlvhit/gocron"
)
type locker struct {
cache *redis.Client
}
func (s *locker) Lock(key string) (success bool, err error) {
res, err := s.cache.SetNX(key, time.Now().String(), time.Second*15).Result()
if err != nil {
re... | {
fmt.Printf("Hello, %s!\n", name)
t := time.NewTicker(time.Millisecond * 100)
c := make(chan struct{})
time.AfterFunc(time.Second*5, func() {
close(c)
})
for {
select {
case <-t.C:
fmt.Print(".")
case <-c:
fmt.Println()
return
}
}
} |
package identity
import (
"github.com/oracle/oci-go-sdk/v46/common"
"net/http"
)
type ListTaggingWorkRequestErrorsRequest struct {
WorkRequestId *string `mandatory:"true" contributesTo:"path" name:"workRequestId"`
Page *string `mandatory:"false" contributesTo:"query" name:"page"`
Limit *int `mandatory:"f... | {
return common.PointerString(response)
} |
package main
import (
"strconv"
"strings"
)
func ParseForCommands(line string) string {
switch line {
case ":g":
SelectGuild()
line = ""
case ":c":
SelectChannel()
line = ""
default:
}
if strings.HasPrefix(line, ":m") {
AmountStr := strings.Split(line, " ")
if len(AmountStr) < 2 {
Msg(ErrorMs... | {
State.Enabled = false
SelectChannelMenu()
State.Enabled = true
ShowContent()
} |
package backoff
import (
"context"
"time"
)
type BackOffContext interface {
BackOff
Context() context.Context
}
type backOffContext struct {
BackOff
ctx context.Context
}
func WithContext(b BackOff, ctx context.Context) BackOffContext {
if ctx == nil {
panic("nil context")
}
if b, ok := b.(*backOff... | {
if cb, ok := b.(BackOffContext); ok {
return cb
}
return WithContext(b, context.Background())
} |
package state
import (
"net/url"
"gopkg.in/juju/charm.v3"
)
type charmDoc struct {
URL *charm.URL `bson:"_id"`
Meta *charm.Meta
Config *charm.Config
Actions *charm.Actions
BundleURL *url.URL
BundleSha256 string
PendingUpload bool
Placeholder bool
}
type Charm struc... | {
clone := *c.doc.URL
return &clone
} |
package dax
type Grapher interface {
GetParent() Grapher
AddChild(child Grapher)
GetChildren() []Grapher
}
type nodeStack struct {
nodes []Grapher
}
func (s *nodeStack) Init() {
s.nodes = make([]Grapher, 0, 16)
}
func (s *nodeStack) Empty() bool {
return len(s.nodes) == 0
}
func (s *nodeStack) Push(n Graphe... | {
sg.updateWorldTransform()
} |
package internal
import G "github.com/ionous/sashimi/game"
type PendingChain struct {
src *GameEventAdapter
}
func (c PendingChain) Then(cb G.Callback) {
if c.src != nil {
chain := ChainedCallback{c.src.data, cb}
chain.Run(c.src.Game)
}
}
func NewPendingChain(src *GameEventAdapter, _ Future) PendingChain | {
return PendingChain{src}
} |
package query
func shouldEscape(c byte) bool {
if 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' {
return false
}
switch c {
case '-', '_', '.', '~':
return false
}
return true
}
func Escape(s string) string | {
hexCount := 0
for i := 0; i < len(s); i++ {
c := s[i]
if shouldEscape(c) {
hexCount++
}
}
if hexCount == 0 {
return s
}
t := make([]byte, len(s)+2*hexCount)
j := 0
for i := 0; i < len(s); i++ {
switch c := s[i]; {
case shouldEscape(c):
t[j] = '%'
t[j+1] = "0123456789ABCDEF"[c>>4]
t[j... |
package protobuf
import "github.com/m3db/m3x/pool"
const (
defaultInitBufferSize = 2880
defaultMaxUnaggregatedMessageSize = 50 * 1024 * 1024
)
type UnaggregatedOptions interface {
SetBytesPool(value pool.BytesPool) UnaggregatedOptions
BytesPool() pool.BytesPool
SetInitBufferSize(value int) UnaggregatedOptio... | {
return o.bytesPool
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.