_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q34400 | New | train | func New(i interface{}) *Nulls {
if _, ok := i.(nullable); !ok {
return nil
}
return &Nulls{Value: i}
} | go | {
"resource": ""
} |
q34401 | Scan | train | func (f *Float) Scan(src interface{}) error {
b, ok := src.([]byte)
if !ok {
return errors.New("Scan source was not []byte")
}
str := string(b)
*f = strToFloat(str)
return nil
} | go | {
"resource": ""
} |
q34402 | Value | train | func (f Float) Value() (driver.Value, error) {
sa := make([]string, len(f))
for x, i := range f {
sa[x] = strconv.FormatFloat(i, 'f', -1, 64)
}
return fmt.Sprintf("{%s}", strings.Join(sa, ",")), nil
} | go | {
"resource": ""
} |
q34403 | UnmarshalText | train | func (f *Float) UnmarshalText(text []byte) error {
var ss []float64
for _, x := range strings.Split(string(text), ",") {
f, err := strconv.ParseFloat(x, 64)
if err != nil {
return errors.WithStack(err)
}
ss = append(ss, f)
}
*f = ss
return nil
} | go | {
"resource": ""
} |
q34404 | NewFileMigrator | train | func NewFileMigrator(path string, c *Connection) (FileMigrator, error) {
fm := FileMigrator{
Migrator: NewMigrator(c),
Path: path,
}
fm.SchemaPath = path
err := fm.findMigrations()
if err != nil {
return fm, errors.WithStack(err)
}
return fm, nil
} | go | {
"resource": ""
} |
q34405 | Next | train | func (s *scanner) Next() (rune, bool) {
if s.i >= len(s.s) {
return 0, false
}
r := s.s[s.i]
s.i++
return r, true
} | go | {
"resource": ""
} |
q34406 | SkipSpaces | train | func (s *scanner) SkipSpaces() (rune, bool) {
r, ok := s.Next()
for unicode.IsSpace(r) && ok {
r, ok = s.Next()
}
return r, ok
} | go | {
"resource": ""
} |
q34407 | parseOpts | train | func parseOpts(name string, o values) error {
s := newScanner(name)
for {
var (
keyRunes, valRunes []rune
r rune
ok bool
)
if r, ok = s.SkipSpaces(); !ok {
break
}
// Scan the key
for !unicode.IsSpace(r) && r != '=' {
keyRunes = append(keyRunes, r)
if ... | go | {
"resource": ""
} |
q34408 | Scan | train | func (i *Int) Scan(src interface{}) error {
b, ok := src.([]byte)
if !ok {
return errors.New("Scan source was not []byte")
}
str := string(b)
*i = strToInt(str)
return nil
} | go | {
"resource": ""
} |
q34409 | Value | train | func (i Int) Value() (driver.Value, error) {
sa := make([]string, len(i))
for x, v := range i {
sa[x] = strconv.Itoa(v)
}
return fmt.Sprintf("{%s}", strings.Join(sa, ",")), nil
} | go | {
"resource": ""
} |
q34410 | UnmarshalText | train | func (i *Int) UnmarshalText(text []byte) error {
var ss []int
for _, x := range strings.Split(string(text), ",") {
f, err := strconv.Atoi(x)
if err != nil {
return errors.WithStack(err)
}
ss = append(ss, f)
}
*i = ss
return nil
} | go | {
"resource": ""
} |
q34411 | ForStructWithAlias | train | func ForStructWithAlias(s interface{}, tableName string, tableAlias string) (columns Columns) {
columns = NewColumnsWithAlias(tableName, tableAlias)
defer func() {
if r := recover(); r != nil {
columns = NewColumnsWithAlias(tableName, tableAlias)
columns.Add("*")
}
}()
st := reflect.TypeOf(s)
if st.Kind(... | go | {
"resource": ""
} |
q34412 | Paginate | train | func (p Paginator) Paginate() string {
b, _ := json.Marshal(p)
return string(b)
} | go | {
"resource": ""
} |
q34413 | NewPaginator | train | func NewPaginator(page int, perPage int) *Paginator {
if page < 1 {
page = 1
}
if perPage < 1 {
perPage = 20
}
p := &Paginator{Page: page, PerPage: perPage}
p.Offset = (page - 1) * p.PerPage
return p
} | go | {
"resource": ""
} |
q34414 | NewPaginatorFromParams | train | func NewPaginatorFromParams(params PaginationParams) *Paginator {
page := defaults.String(params.Get("page"), "1")
perPage := defaults.String(params.Get("per_page"), strconv.Itoa(PaginatorPerPageDefault))
p, err := strconv.Atoi(page)
if err != nil {
p = 1
}
pp, err := strconv.Atoi(perPage)
if err != nil {
... | go | {
"resource": ""
} |
q34415 | Anko | train | func Anko(content string) (string, error) {
bb := &bytes.Buffer{}
lines := strings.Split(content, "\n")
l := len(lines)
fre := regexp.MustCompile(`,\s*func\(t\)\s*{`)
for i := 0; i < l; i++ {
line := lines[i]
tl := strings.TrimSpace(line)
if strings.HasPrefix(tl, "create_table") {
// skip already conver... | go | {
"resource": ""
} |
q34416 | UpdateString | train | func (c WriteableColumns) UpdateString() string {
var xs []string
for _, t := range c.Cols {
xs = append(xs, t.UpdateString())
}
sort.Strings(xs)
return strings.Join(xs, ", ")
} | go | {
"resource": ""
} |
q34417 | SelectString | train | func (c ReadableColumns) SelectString() string {
var xs []string
for _, t := range c.Cols {
xs = append(xs, t.SelectSQL)
}
sort.Strings(xs)
return strings.Join(xs, ", ")
} | go | {
"resource": ""
} |
q34418 | withURL | train | func (cd *ConnectionDetails) withURL() error {
ul := cd.URL
if cd.Dialect == "" {
if dialectX.MatchString(ul) {
// Guess the dialect from the scheme
dialect := ul[:strings.Index(ul, ":")]
cd.Dialect = normalizeSynonyms(dialect)
} else {
return errors.New("no dialect provided, and could not guess it fr... | go | {
"resource": ""
} |
q34419 | Finalize | train | func (cd *ConnectionDetails) Finalize() error {
cd.Dialect = normalizeSynonyms(cd.Dialect)
if cd.Options == nil { // for safety
cd.Options = make(map[string]string)
}
// Process the database connection string, if provided.
if cd.URL != "" {
if err := cd.withURL(); err != nil {
return err
}
}
if fin, ... | go | {
"resource": ""
} |
q34420 | RetrySleep | train | func (cd *ConnectionDetails) RetrySleep() time.Duration {
d, err := time.ParseDuration(defaults.String(cd.Options["retry_sleep"], "1ms"))
if err != nil {
return 1 * time.Millisecond
}
return d
} | go | {
"resource": ""
} |
q34421 | RetryLimit | train | func (cd *ConnectionDetails) RetryLimit() int {
i, err := strconv.Atoi(defaults.String(cd.Options["retry_limit"], "1000"))
if err != nil {
return 100
}
return i
} | go | {
"resource": ""
} |
q34422 | OptionsString | train | func (cd *ConnectionDetails) OptionsString(s string) string {
if cd.RawOptions != "" {
return cd.RawOptions
}
if cd.Options != nil {
for k, v := range cd.Options {
s = fmt.Sprintf("%s&%s=%s", s, k, v)
}
}
return strings.TrimLeft(s, "&")
} | go | {
"resource": ""
} |
q34423 | DropDB | train | func DropDB(c *Connection) error {
deets := c.Dialect.Details()
if deets.Database != "" {
log(logging.Info, fmt.Sprintf("drop %s (%s)", deets.Database, c.URL()))
return errors.Wrapf(c.Dialect.DropDB(), "couldn't drop database %s", deets.Database)
}
return nil
} | go | {
"resource": ""
} |
q34424 | Add | train | func (c *Columns) Add(names ...string) []*Column {
var ret []*Column
c.lock.Lock()
tableAlias := c.TableAlias
if tableAlias == "" {
tableAlias = c.TableName
}
for _, name := range names {
var xs []string
var col *Column
ss := ""
//support for distinct xx, or distinct on (field) table.fields
if stri... | go | {
"resource": ""
} |
q34425 | Remove | train | func (c *Columns) Remove(names ...string) {
for _, name := range names {
xs := strings.Split(name, ",")
name = xs[0]
delete(c.Cols, name)
}
} | go | {
"resource": ""
} |
q34426 | Writeable | train | func (c Columns) Writeable() *WriteableColumns {
w := &WriteableColumns{NewColumnsWithAlias(c.TableName, c.TableAlias)}
for _, col := range c.Cols {
if col.Writeable {
w.Cols[col.Name] = col
}
}
return w
} | go | {
"resource": ""
} |
q34427 | Readable | train | func (c Columns) Readable() *ReadableColumns {
w := &ReadableColumns{NewColumnsWithAlias(c.TableName, c.TableAlias)}
for _, col := range c.Cols {
if col.Readable {
w.Cols[col.Name] = col
}
}
return w
} | go | {
"resource": ""
} |
q34428 | NewColumnsWithAlias | train | func NewColumnsWithAlias(tableName string, tableAlias string) Columns {
return Columns{
lock: &sync.RWMutex{},
Cols: map[string]*Column{},
TableName: tableName,
TableAlias: tableAlias,
}
} | go | {
"resource": ""
} |
q34429 | Run | train | func (mf Migration) Run(c *Connection) error {
if mf.Runner == nil {
return errors.Errorf("no runner defined for %s", mf.Path)
}
return mf.Runner(mf, c)
} | go | {
"resource": ""
} |
q34430 | Reload | train | func (c *Connection) Reload(model interface{}) error {
sm := Model{Value: model}
return sm.iterate(func(m *Model) error {
return c.Find(m.Value, m.ID())
})
} | go | {
"resource": ""
} |
q34431 | Exec | train | func (q *Query) Exec() error {
return q.Connection.timeFunc("Exec", func() error {
sql, args := q.ToSQL(nil)
log(logging.SQL, sql, args...)
_, err := q.Connection.Store.Exec(sql, args...)
return err
})
} | go | {
"resource": ""
} |
q34432 | ExecWithCount | train | func (q *Query) ExecWithCount() (int, error) {
count := int64(0)
return int(count), q.Connection.timeFunc("Exec", func() error {
sql, args := q.ToSQL(nil)
log(logging.SQL, sql, args...)
result, err := q.Connection.Store.Exec(sql, args...)
if err != nil {
return err
}
count, err = result.RowsAffected()... | go | {
"resource": ""
} |
q34433 | ValidateAndSave | train | func (c *Connection) ValidateAndSave(model interface{}, excludeColumns ...string) (*validate.Errors, error) {
sm := &Model{Value: model}
verrs, err := sm.validateSave(c)
if err != nil {
return verrs, err
}
if verrs.HasAny() {
return verrs, nil
}
return verrs, c.Save(model, excludeColumns...)
} | go | {
"resource": ""
} |
q34434 | IsZeroOfUnderlyingType | train | func IsZeroOfUnderlyingType(x interface{}) bool {
return reflect.DeepEqual(x, reflect.Zero(reflect.TypeOf(x)).Interface())
} | go | {
"resource": ""
} |
q34435 | Save | train | func (c *Connection) Save(model interface{}, excludeColumns ...string) error {
sm := &Model{Value: model}
return sm.iterate(func(m *Model) error {
id, err := m.fieldByName("ID")
if err != nil {
return err
}
if IsZeroOfUnderlyingType(id.Interface()) {
return c.Create(m.Value, excludeColumns...)
}
ret... | go | {
"resource": ""
} |
q34436 | ValidateAndCreate | train | func (c *Connection) ValidateAndCreate(model interface{}, excludeColumns ...string) (*validate.Errors, error) {
sm := &Model{Value: model}
verrs, err := sm.validateCreate(c)
if err != nil {
return verrs, err
}
if verrs.HasAny() {
return verrs, nil
}
if c.eager {
asos, err2 := associations.ForStruct(model,... | go | {
"resource": ""
} |
q34437 | ValidateAndUpdate | train | func (c *Connection) ValidateAndUpdate(model interface{}, excludeColumns ...string) (*validate.Errors, error) {
sm := &Model{Value: model}
verrs, err := sm.validateUpdate(c)
if err != nil {
return verrs, err
}
if verrs.HasAny() {
return verrs, nil
}
return verrs, c.Update(model, excludeColumns...)
} | go | {
"resource": ""
} |
q34438 | Update | train | func (c *Connection) Update(model interface{}, excludeColumns ...string) error {
sm := &Model{Value: model}
return sm.iterate(func(m *Model) error {
return c.timeFunc("Update", func() error {
var err error
if err = m.beforeSave(c); err != nil {
return err
}
if err = m.beforeUpdate(c); err != nil {
... | go | {
"resource": ""
} |
q34439 | Destroy | train | func (c *Connection) Destroy(model interface{}) error {
sm := &Model{Value: model}
return sm.iterate(func(m *Model) error {
return c.timeFunc("Destroy", func() error {
var err error
if err = m.beforeDestroy(c); err != nil {
return err
}
if err = c.Dialect.Destroy(c.Store, m); err != nil {
retur... | go | {
"resource": ""
} |
q34440 | Model | train | func Model(name string, opts map[string]interface{}, attributes []string) error {
if strings.TrimSpace(name) == "" {
return errors.New("model name can't be empty")
}
mt, found := opts["marshalType"].(string)
if !found {
return errors.New("marshalType option is required")
}
pp, found := opts["modelPath"].(str... | go | {
"resource": ""
} |
q34441 | New | train | func New(opts *Options) (*genny.Generator, error) {
g := genny.New()
if err := opts.Validate(); err != nil {
return g, errors.WithStack(err)
}
f, err := templates.Open(opts.Dialect + ".yml.tmpl")
if err != nil {
return g, errors.Errorf("unable to find database.yml template for dialect %s", opts.Dialect)
}
... | go | {
"resource": ""
} |
q34442 | GroupBy | train | func (q *Query) GroupBy(field string, fields ...string) *Query {
if q.RawSQL.Fragment != "" {
log(logging.Warn, "Query is setup to use raw SQL")
return q
}
q.groupClauses = append(q.groupClauses, GroupClause{field})
if len(fields) > 0 {
for i := range fields {
q.groupClauses = append(q.groupClauses, GroupC... | go | {
"resource": ""
} |
q34443 | Constraint | train | func (h *hasOneAssociation) Constraint() (string, []interface{}) {
return fmt.Sprintf("%s = ?", h.fkID), []interface{}{h.ownerID}
} | go | {
"resource": ""
} |
q34444 | AfterInterface | train | func (h *hasOneAssociation) AfterInterface() interface{} {
m := h.ownedModel
if fieldIsNil(m) {
return nil
}
if m.Kind() == reflect.Ptr {
return m.Interface()
}
if IsZeroOfUnderlyingType(m.Interface()) {
return nil
}
return m.Addr().Interface()
} | go | {
"resource": ""
} |
q34445 | LoadConfigFile | train | func LoadConfigFile() error {
path, err := findConfigPath()
if err != nil {
return errors.WithStack(err)
}
Connections = map[string]*Connection{}
log(logging.Debug, "Loading config file from %s", path)
f, err := os.Open(path)
if err != nil {
return errors.WithStack(err)
}
return LoadFrom(f)
} | go | {
"resource": ""
} |
q34446 | LoadFrom | train | func LoadFrom(r io.Reader) error {
envy.Load()
deets, err := ParseConfig(r)
if err != nil {
return err
}
for n, d := range deets {
con, err := NewConnection(d)
if err != nil {
log(logging.Warn, "unable to load connection %s: %v", n, err)
continue
}
Connections[n] = con
}
return nil
} | go | {
"resource": ""
} |
q34447 | ParseConfig | train | func ParseConfig(r io.Reader) (map[string]*ConnectionDetails, error) {
tmpl := template.New("test")
tmpl.Funcs(map[string]interface{}{
"envOr": func(s1, s2 string) string {
return envy.Get(s1, s2)
},
"env": func(s1 string) string {
return envy.Get(s1, "")
},
})
b, err := ioutil.ReadAll(r)
if err != n... | go | {
"resource": ""
} |
q34448 | AssociationsBeforeCreatable | train | func (a Associations) AssociationsBeforeCreatable() []AssociationBeforeCreatable {
var before []AssociationBeforeCreatable
for i := range a {
if _, ok := a[i].(AssociationBeforeCreatable); ok {
before = append(before, a[i].(AssociationBeforeCreatable))
}
}
return before
} | go | {
"resource": ""
} |
q34449 | AssociationsAfterCreatable | train | func (a Associations) AssociationsAfterCreatable() []AssociationAfterCreatable {
var after []AssociationAfterCreatable
for i := range a {
if _, ok := a[i].(AssociationAfterCreatable); ok {
after = append(after, a[i].(AssociationAfterCreatable))
}
}
return after
} | go | {
"resource": ""
} |
q34450 | AssociationsCreatableStatement | train | func (a Associations) AssociationsCreatableStatement() []AssociationCreatableStatement {
var stm []AssociationCreatableStatement
for i := range a {
if _, ok := a[i].(AssociationCreatableStatement); ok {
stm = append(stm, a[i].(AssociationCreatableStatement))
}
}
return stm
} | go | {
"resource": ""
} |
q34451 | fieldIsNil | train | func fieldIsNil(f reflect.Value) bool {
if n := nulls.New(f.Interface()); n != nil {
return n.Interface() == nil
}
if f.Kind() == reflect.Interface || f.Kind() == reflect.Ptr {
return f.IsNil()
}
return f.Interface() == nil
} | go | {
"resource": ""
} |
q34452 | NewConnection | train | func NewConnection(deets *ConnectionDetails) (*Connection, error) {
err := deets.Finalize()
if err != nil {
return nil, errors.WithStack(err)
}
c := &Connection{
ID: randx.String(30),
}
if nc, ok := newConnection[deets.Dialect]; ok {
c.Dialect, err = nc(deets)
if err != nil {
return c, errors.Wrap(err... | go | {
"resource": ""
} |
q34453 | Connect | train | func Connect(e string) (*Connection, error) {
if len(Connections) == 0 {
err := LoadConfigFile()
if err != nil {
return nil, errors.WithStack(err)
}
}
e = defaults.String(e, "development")
c := Connections[e]
if c == nil {
return c, errors.Errorf("could not find connection named %s", e)
}
err := c.Ope... | go | {
"resource": ""
} |
q34454 | Open | train | func (c *Connection) Open() error {
if c.Store != nil {
return nil
}
if c.Dialect == nil {
return errors.New("invalid connection instance")
}
details := c.Dialect.Details()
db, err := sqlx.Open(details.Dialect, c.Dialect.URL())
if err != nil {
return errors.Wrap(err, "could not open database connection")
... | go | {
"resource": ""
} |
q34455 | Transaction | train | func (c *Connection) Transaction(fn func(tx *Connection) error) error {
return c.Dialect.Lock(func() error {
var dberr error
cn, err := c.NewTransaction()
if err != nil {
return err
}
err = fn(cn)
if err != nil {
dberr = cn.TX.Rollback()
} else {
dberr = cn.TX.Commit()
}
if err != nil {
r... | go | {
"resource": ""
} |
q34456 | Rollback | train | func (c *Connection) Rollback(fn func(tx *Connection)) error {
cn, err := c.NewTransaction()
if err != nil {
return err
}
fn(cn)
return cn.TX.Rollback()
} | go | {
"resource": ""
} |
q34457 | NewTransaction | train | func (c *Connection) NewTransaction() (*Connection, error) {
var cn *Connection
if c.TX == nil {
tx, err := c.Store.Transaction()
if err != nil {
return cn, errors.Wrap(err, "couldn't start a new transaction")
}
cn = &Connection{
ID: randx.String(30),
Store: tx,
Dialect: c.Dialect,
TX: ... | go | {
"resource": ""
} |
q34458 | Find | train | func (t Tags) Find(name string) Tag {
for _, popTag := range t {
if popTag.Name == name {
return popTag
}
}
return Tag{}
} | go | {
"resource": ""
} |
q34459 | TagsFor | train | func TagsFor(field reflect.StructField) Tags {
pTags := Tags{}
for _, tag := range strings.Fields(tags) {
if valTag := field.Tag.Get(tag); valTag != "" {
pTags = append(pTags, Tag{valTag, tag})
}
}
if len(pTags) == 0 {
pTags = append(pTags, Tag{field.Name, "db"})
}
return pTags
} | go | {
"resource": ""
} |
q34460 | Scan | train | func (s *String) Scan(src interface{}) error {
ss := pq.StringArray(*s)
err := ss.Scan(src)
*s = String(ss)
return err
} | go | {
"resource": ""
} |
q34461 | Value | train | func (s String) Value() (driver.Value, error) {
ss := pq.StringArray(s)
return ss.Value()
} | go | {
"resource": ""
} |
q34462 | UnmarshalJSON | train | func (s *String) UnmarshalJSON(data []byte) error {
var ss pq.StringArray
if err := json.Unmarshal(data, &ss); err != nil {
return err
}
*s = String(ss)
return nil
} | go | {
"resource": ""
} |
q34463 | UnmarshalText | train | func (s *String) UnmarshalText(text []byte) error {
r := csv.NewReader(bytes.NewReader(text))
var words []string
for {
record, err := r.Read()
if err == io.EOF {
break
}
if err != nil {
return err
}
words = append(words, record...)
}
*s = String(words)
return nil
} | go | {
"resource": ""
} |
q34464 | Parse | train | func Parse(w io.Writer, r io.Reader, filename, pkg string) error {
p := &parser{
s: newScanner(r, filename),
w: w,
packageName: pkg,
}
return p.parseTemplate()
} | go | {
"resource": ""
} |
q34465 | AcquireWriter | train | func AcquireWriter(w io.Writer) *Writer {
v := writerPool.Get()
if v == nil {
qw := &Writer{}
qw.e.w = &htmlEscapeWriter{}
v = qw
}
qw := v.(*Writer)
qw.e.w.(*htmlEscapeWriter).w = w
qw.n.w = w
return qw
} | go | {
"resource": ""
} |
q34466 | ReleaseWriter | train | func ReleaseWriter(qw *Writer) {
hw := qw.e.w.(*htmlEscapeWriter)
hw.w = nil
qw.e.Reset()
qw.e.w = hw
qw.n.Reset()
writerPool.Put(qw)
} | go | {
"resource": ""
} |
q34467 | D | train | func (w *QWriter) D(n int) {
bb, ok := w.w.(*ByteBuffer)
if ok {
bb.B = strconv.AppendInt(bb.B, int64(n), 10)
} else {
w.b = strconv.AppendInt(w.b[:0], int64(n), 10)
w.Write(w.b)
}
} | go | {
"resource": ""
} |
q34468 | F | train | func (w *QWriter) F(f float64) {
n := int(f)
if float64(n) == f {
// Fast path - just int.
w.D(n)
return
}
// Slow path.
w.FPrec(f, -1)
} | go | {
"resource": ""
} |
q34469 | FPrec | train | func (w *QWriter) FPrec(f float64, prec int) {
bb, ok := w.w.(*ByteBuffer)
if ok {
bb.B = strconv.AppendFloat(bb.B, f, 'f', prec, 64)
} else {
w.b = strconv.AppendFloat(w.b[:0], f, 'f', prec, 64)
w.Write(w.b)
}
} | go | {
"resource": ""
} |
q34470 | Q | train | func (w *QWriter) Q(s string) {
w.Write(strQuote)
writeJSONString(w, s)
w.Write(strQuote)
} | go | {
"resource": ""
} |
q34471 | U | train | func (w *QWriter) U(s string) {
bb, ok := w.w.(*ByteBuffer)
if ok {
bb.B = appendURLEncode(bb.B, s)
} else {
w.b = appendURLEncode(w.b[:0], s)
w.Write(w.b)
}
} | go | {
"resource": ""
} |
q34472 | GetLimitFromParameter | train | func GetLimitFromParameter(param interface{}, min, def uint64) (uint64, error) {
limit := def
switch v := param.(type) {
case string:
var err error
if limit, err = strconv.ParseUint(v, 0, 64); err != nil {
return limit, fmt.Errorf("parameter must be an integer, '%v' invalid", param)
}
case uint64:
limit... | go | {
"resource": ""
} |
q34473 | NewRegulator | train | func NewRegulator(driver storagedriver.StorageDriver, limit uint64) storagedriver.StorageDriver {
return ®ulator{
StorageDriver: driver,
Cond: sync.NewCond(&sync.Mutex{}),
available: limit,
}
} | go | {
"resource": ""
} |
q34474 | Name | train | func (r *regulator) Name() string {
r.enter()
defer r.exit()
return r.StorageDriver.Name()
} | go | {
"resource": ""
} |
q34475 | Writer | train | func (r *regulator) Writer(ctx context.Context, path string, append bool) (storagedriver.FileWriter, error) {
r.enter()
defer r.exit()
return r.StorageDriver.Writer(ctx, path, append)
} | go | {
"resource": ""
} |
q34476 | URLFor | train | func (r *regulator) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
r.enter()
defer r.exit()
return r.StorageDriver.URLFor(ctx, path, options)
} | go | {
"resource": ""
} |
q34477 | URLFor | train | func (d *driver) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
if d.SecretKey == "" {
return "", storagedriver.ErrUnsupportedMethod{}
}
methodString := "GET"
method, ok := options["method"]
if ok {
if methodString, ok = method.(string); !ok {
return "", storaged... | go | {
"resource": ""
} |
q34478 | References | train | func (m Manifest) References() []distribution.Descriptor {
references := make([]distribution.Descriptor, 0, 1+len(m.Layers))
references = append(references, m.Config)
references = append(references, m.Layers...)
return references
} | go | {
"resource": ""
} |
q34479 | FromStruct | train | func FromStruct(m Manifest) (*DeserializedManifest, error) {
var deserialized DeserializedManifest
deserialized.Manifest = m
var err error
deserialized.canonical, err = json.MarshalIndent(&m, "", " ")
return &deserialized, err
} | go | {
"resource": ""
} |
q34480 | MarshalJSON | train | func (m *DeserializedManifest) MarshalJSON() ([]byte, error) {
if len(m.canonical) > 0 {
return m.canonical, nil
}
return nil, errors.New("JSON representation not initialized in DeserializedManifest")
} | go | {
"resource": ""
} |
q34481 | resumeDigest | train | func (bw *blobWriter) resumeDigest(ctx context.Context) error {
if !bw.resumableDigestEnabled {
return errResumableDigestNotAvailable
}
h, ok := bw.digester.Hash().(encoding.BinaryUnmarshaler)
if !ok {
return errResumableDigestNotAvailable
}
offset := bw.fileWriter.Size()
if offset == bw.written {
// Sta... | go | {
"resource": ""
} |
q34482 | getStoredHashStates | train | func (bw *blobWriter) getStoredHashStates(ctx context.Context) ([]hashStateEntry, error) {
uploadHashStatePathPrefix, err := pathFor(uploadHashStatePathSpec{
name: bw.blobStore.repository.Named().String(),
id: bw.id,
alg: bw.digester.Digest().Algorithm(),
list: true,
})
if err != nil {
return nil, err
... | go | {
"resource": ""
} |
q34483 | Repositories | train | func (reg *registry) Repositories(ctx context.Context, repos []string, last string) (n int, err error) {
var finishedWalk bool
var foundRepos []string
if len(repos) == 0 {
return 0, errors.New("no space in slice")
}
root, err := pathFor(repositoriesRootPathSpec{})
if err != nil {
return 0, err
}
err = re... | go | {
"resource": ""
} |
q34484 | Enumerate | train | func (reg *registry) Enumerate(ctx context.Context, ingester func(string) error) error {
root, err := pathFor(repositoriesRootPathSpec{})
if err != nil {
return err
}
err = reg.blobStore.driver.Walk(ctx, root, func(fileInfo driver.FileInfo) error {
return handleRepository(fileInfo, root, "", ingester)
})
re... | go | {
"resource": ""
} |
q34485 | Remove | train | func (reg *registry) Remove(ctx context.Context, name reference.Named) error {
root, err := pathFor(repositoriesRootPathSpec{})
if err != nil {
return err
}
repoDir := path.Join(root, name.Name())
return reg.driver.Delete(ctx, repoDir)
} | go | {
"resource": ""
} |
q34486 | compareReplaceInline | train | func compareReplaceInline(s1, s2 string, old, new byte) int {
// TODO(stevvooe): We are missing an optimization when the s1 and s2 have
// the exact same slice header. It will make the code unsafe but can
// provide some extra performance.
l := len(s1)
if len(s2) < l {
l = len(s2)
}
for i := 0; i < l; i++ {
... | go | {
"resource": ""
} |
q34487 | handleRepository | train | func handleRepository(fileInfo driver.FileInfo, root, last string, fn func(repoPath string) error) error {
filePath := fileInfo.Path()
// lop the base path off
repo := filePath[len(root)+1:]
_, file := path.Split(repo)
if file == "_layers" {
repo = strings.TrimSuffix(repo, "/_layers")
if lessPath(last, repo)... | go | {
"resource": ""
} |
q34488 | URLFor | train | func (lh *cloudFrontStorageMiddleware) URLFor(ctx context.Context, path string, options map[string]interface{}) (string, error) {
// TODO(endophage): currently only supports S3
keyer, ok := lh.StorageDriver.(S3BucketKeyer)
if !ok {
dcontext.GetLogger(ctx).Warn("the CloudFront middleware does not support this backe... | go | {
"resource": ""
} |
q34489 | digestFromPath | train | func digestFromPath(digestPath string) (digest.Digest, error) {
digestPath = strings.TrimSuffix(digestPath, "/data")
dir, hex := path.Split(digestPath)
dir = path.Dir(dir)
dir, next := path.Split(dir)
// next is either the algorithm OR the first two characters in the hex string
var algo string
if next == hex[:... | go | {
"resource": ""
} |
q34490 | Commit | train | func (bw *blobWriter) Commit(ctx context.Context, desc distribution.Descriptor) (distribution.Descriptor, error) {
dcontext.GetLogger(ctx).Debug("(*blobWriter).Commit")
if err := bw.fileWriter.Commit(); err != nil {
return distribution.Descriptor{}, err
}
bw.Close()
desc.Size = bw.Size()
canonical, err := bw... | go | {
"resource": ""
} |
q34491 | Cancel | train | func (bw *blobWriter) Cancel(ctx context.Context) error {
dcontext.GetLogger(ctx).Debug("(*blobWriter).Cancel")
if err := bw.fileWriter.Cancel(); err != nil {
return err
}
if err := bw.Close(); err != nil {
dcontext.GetLogger(ctx).Errorf("error closing blobwriter: %s", err)
}
return bw.removeResources(ctx)
... | go | {
"resource": ""
} |
q34492 | moveBlob | train | func (bw *blobWriter) moveBlob(ctx context.Context, desc distribution.Descriptor) error {
blobPath, err := pathFor(blobDataPathSpec{
digest: desc.Digest,
})
if err != nil {
return err
}
// Check for existence
if _, err := bw.blobStore.driver.Stat(ctx, blobPath); err != nil {
switch err := err.(type) {
c... | go | {
"resource": ""
} |
q34493 | removeResources | train | func (bw *blobWriter) removeResources(ctx context.Context) error {
dataPath, err := pathFor(uploadDataPathSpec{
name: bw.blobStore.repository.Named().Name(),
id: bw.id,
})
if err != nil {
return err
}
// Resolve and delete the containing directory, which should include any
// upload related files.
dirP... | go | {
"resource": ""
} |
q34494 | Verify | train | func Verify(sm *SignedManifest) ([]libtrust.PublicKey, error) {
js, err := libtrust.ParsePrettySignature(sm.all, "signatures")
if err != nil {
logrus.WithField("err", err).Debugf("(*SignedManifest).Verify")
return nil, err
}
return js.Verify()
} | go | {
"resource": ""
} |
q34495 | VerifyChains | train | func VerifyChains(sm *SignedManifest, ca *x509.CertPool) ([][]*x509.Certificate, error) {
js, err := libtrust.ParsePrettySignature(sm.all, "signatures")
if err != nil {
return nil, err
}
return js.VerifyChains(ca)
} | go | {
"resource": ""
} |
q34496 | configureAuth | train | func configureAuth(username, password, remoteURL string) (auth.CredentialStore, error) {
creds := map[string]userpass{}
authURLs, err := getAuthURLs(remoteURL)
if err != nil {
return nil, err
}
for _, url := range authURLs {
context.GetLogger(context.Background()).Infof("Discovered token authentication URL: ... | go | {
"resource": ""
} |
q34497 | add | train | func (d *dir) add(n node) {
if d.children == nil {
d.children = make(map[string]node)
}
d.children[n.name()] = n
d.mod = time.Now()
} | go | {
"resource": ""
} |
q34498 | mkfile | train | func (d *dir) mkfile(p string) (*file, error) {
n := d.find(p)
if n.path() == p {
if n.isdir() {
return nil, errIsDir
}
return n.(*file), nil
}
dirpath, filename := path.Split(p)
// Make any non-existent directories
n, err := d.mkdirs(dirpath)
if err != nil {
return nil, err
}
dd := n.(*dir)
n =... | go | {
"resource": ""
} |
q34499 | mkdirs | train | func (d *dir) mkdirs(p string) (*dir, error) {
p = normalize(p)
n := d.find(p)
if !n.isdir() {
// Found something there
return nil, errIsNotDir
}
if n.path() == p {
return n.(*dir), nil
}
dd := n.(*dir)
relative := strings.Trim(strings.TrimPrefix(p, n.path()), "/")
if relative == "" {
return dd, ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.