_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14300 | PostForm | train | func (c *Context) PostForm(key string, defaultValue ...string) string {
r := c.Request
r.ParseMultipartForm(32 << 20)
if vs := r.PostForm[key]; len(vs) > 0 {
return vs[0]
}
if len(defaultValue) > 0 {
return defaultValue[0]
}
return ""
} | go | {
"resource": ""
} |
q14301 | Next | train | func (c *Context) Next() error {
c.index++
for n := len(c.handlers); c.index < n; c.index++ {
if err := c.handlers[c.index](c); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q14302 | Read | train | func (c *Context) Read(data interface{}) error {
if c.Request.Method != "GET" {
t := getContentType(c.Request)
if reader, ok := DataReaders[t]; ok {
return reader.Read(c.Request, data)
}
}
return DefaultFormDataReader.Read(c.Request, data)
} | go | {
"resource": ""
} |
q14303 | negotiateLanguage | train | func negotiateLanguage(r *http.Request, offers []string, defaultOffer string) string {
bestOffer := defaultOffer
bestQ := -1.0
specs := header.ParseAccept(r.Header, "Accept-Language")
for _, offer := range offers {
for _, spec := range specs {
if spec.Q > bestQ && (spec.Value == "*" || spec.Value == offer) {
... | go | {
"resource": ""
} |
q14304 | ReadFormData | train | func ReadFormData(form map[string][]string, data interface{}) error {
rv := reflect.ValueOf(data)
if rv.Kind() != reflect.Ptr || rv.IsNil() {
return errors.New("data must be a pointer")
}
rv = indirect(rv)
if rv.Kind() != reflect.Struct {
return errors.New("data must be a pointer to a struct")
}
return read... | go | {
"resource": ""
} |
q14305 | DefaultJWTTokenHandler | train | func DefaultJWTTokenHandler(c *routing.Context, token *jwt.Token) error {
c.Set("JWT", token)
return nil
} | go | {
"resource": ""
} |
q14306 | NewJWT | train | func NewJWT(claims jwt.MapClaims, signingKey string, signingMethod ...jwt.SigningMethod) (string, error) {
var sm jwt.SigningMethod = jwt.SigningMethodHS256
if len(signingMethod) > 0 {
sm = signingMethod[0]
}
return jwt.NewWithClaims(sm, claims).SignedString([]byte(signingKey))
} | go | {
"resource": ""
} |
q14307 | New | train | func New() *Router {
r := &Router{
namedRoutes: make(map[string]*Route),
stores: make(map[string]routeStore),
}
r.RouteGroup = *newRouteGroup("", r, make([]Handler, 0))
r.NotFound(MethodNotAllowedHandler, NotFoundHandler)
r.pool.New = func() interface{} {
return &Context{
pvalues: make([]string, r.ma... | go | {
"resource": ""
} |
q14308 | ServeHTTP | train | func (r *Router) ServeHTTP(res http.ResponseWriter, req *http.Request) {
c := r.pool.Get().(*Context)
c.init(res, req)
if r.UseEscapedPath {
c.handlers, c.pnames = r.find(req.Method, r.normalizeRequestPath(req.URL.EscapedPath()), c.pvalues)
for i, v := range c.pvalues {
c.pvalues[i], _ = url.QueryUnescape(v)
... | go | {
"resource": ""
} |
q14309 | Use | train | func (r *Router) Use(handlers ...Handler) {
r.RouteGroup.Use(handlers...)
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | go | {
"resource": ""
} |
q14310 | NotFound | train | func (r *Router) NotFound(handlers ...Handler) {
r.notFound = handlers
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | go | {
"resource": ""
} |
q14311 | Find | train | func (r *Router) Find(method, path string) (handlers []Handler, params map[string]string) {
pvalues := make([]string, r.maxParams)
handlers, pnames := r.find(method, path, pvalues)
params = make(map[string]string, len(pnames))
for i, n := range pnames {
params[n] = pvalues[i]
}
return handlers, params
} | go | {
"resource": ""
} |
q14312 | HTTPHandlerFunc | train | func HTTPHandlerFunc(h http.HandlerFunc) Handler {
return func(c *Context) error {
h(c.Response, c.Request)
return nil
}
} | go | {
"resource": ""
} |
q14313 | newStore | train | func newStore() *store {
return &store{
root: &node{
static: true,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: -1,
pnames: []string{},
},
}
} | go | {
"resource": ""
} |
q14314 | Add | train | func (s *store) Add(key string, data interface{}) int {
s.count++
return s.root.add(key, data, s.count)
} | go | {
"resource": ""
} |
q14315 | Get | train | func (s *store) Get(path string, pvalues []string) (data interface{}, pnames []string) {
data, pnames, _ = s.root.get(path, pvalues)
return
} | go | {
"resource": ""
} |
q14316 | add | train | func (n *node) add(key string, data interface{}, order int) int {
matched := 0
// find the common prefix
for ; matched < len(key) && matched < len(n.key); matched++ {
if key[matched] != n.key[matched] {
break
}
}
if matched == len(n.key) {
if matched == len(key) {
// the node key is the same as the k... | go | {
"resource": ""
} |
q14317 | addChild | train | func (n *node) addChild(key string, data interface{}, order int) int {
// find the first occurrence of a param token
p0, p1 := -1, -1
for i := 0; i < len(key); i++ {
if p0 < 0 && key[i] == '<' {
p0 = i
}
if p0 >= 0 && key[i] == '>' {
p1 = i
break
}
}
if p0 > 0 && p1 > 0 || p1 < 0 {
// param tok... | go | {
"resource": ""
} |
q14318 | get | train | func (n *node) get(key string, pvalues []string) (data interface{}, pnames []string, order int) {
order = math.MaxInt32
repeat:
if n.static {
// check if the node key is a prefix of the given key
// a slightly optimized version of strings.HasPrefix
nkl := len(n.key)
if nkl > len(key) {
return
}
for i ... | go | {
"resource": ""
} |
q14319 | safeSet | train | func (b *BitSet) safeSet() []uint64 {
if b.set == nil {
b.set = make([]uint64, wordsNeeded(0))
}
return b.set
} | go | {
"resource": ""
} |
q14320 | wordsNeeded | train | func wordsNeeded(i uint) int {
if i > (Cap() - wordSize + 1) {
return int(Cap() >> log2WordSize)
}
return int((i + (wordSize - 1)) >> log2WordSize)
} | go | {
"resource": ""
} |
q14321 | New | train | func New(length uint) (bset *BitSet) {
defer func() {
if r := recover(); r != nil {
bset = &BitSet{
0,
make([]uint64, 0),
}
}
}()
bset = &BitSet{
length,
make([]uint64, wordsNeeded(length)),
}
return bset
} | go | {
"resource": ""
} |
q14322 | extendSetMaybe | train | func (b *BitSet) extendSetMaybe(i uint) {
if i >= b.length { // if we need more bits, make 'em
nsize := wordsNeeded(i + 1)
if b.set == nil {
b.set = make([]uint64, nsize)
} else if cap(b.set) >= nsize {
b.set = b.set[:nsize] // fast resize
} else if len(b.set) < nsize {
newset := make([]uint64, nsize,... | go | {
"resource": ""
} |
q14323 | Set | train | func (b *BitSet) Set(i uint) *BitSet {
b.extendSetMaybe(i)
b.set[i>>log2WordSize] |= 1 << (i & (wordSize - 1))
return b
} | go | {
"resource": ""
} |
q14324 | Clear | train | func (b *BitSet) Clear(i uint) *BitSet {
if i >= b.length {
return b
}
b.set[i>>log2WordSize] &^= 1 << (i & (wordSize - 1))
return b
} | go | {
"resource": ""
} |
q14325 | SetTo | train | func (b *BitSet) SetTo(i uint, value bool) *BitSet {
if value {
return b.Set(i)
}
return b.Clear(i)
} | go | {
"resource": ""
} |
q14326 | Flip | train | func (b *BitSet) Flip(i uint) *BitSet {
if i >= b.length {
return b.Set(i)
}
b.set[i>>log2WordSize] ^= 1 << (i & (wordSize - 1))
return b
} | go | {
"resource": ""
} |
q14327 | Shrink | train | func (b *BitSet) Shrink(length uint) *BitSet {
idx := wordsNeeded(length + 1)
if idx > len(b.set) {
return b
}
shrunk := make([]uint64, idx)
copy(shrunk, b.set[:idx])
b.set = shrunk
b.length = length + 1
b.set[idx-1] &= (allBits >> (uint64(64) - uint64(length&(wordSize-1)) - 1))
return b
} | go | {
"resource": ""
} |
q14328 | InsertAt | train | func (b *BitSet) InsertAt(idx uint) *BitSet {
insertAtElement := (idx >> log2WordSize)
// if length of set is a multiple of wordSize we need to allocate more space first
if b.isLenExactMultiple() {
b.set = append(b.set, uint64(0))
}
var i uint
for i = uint(len(b.set) - 1); i > insertAtElement; i-- {
// all ... | go | {
"resource": ""
} |
q14329 | ClearAll | train | func (b *BitSet) ClearAll() *BitSet {
if b != nil && b.set != nil {
for i := range b.set {
b.set[i] = 0
}
}
return b
} | go | {
"resource": ""
} |
q14330 | Clone | train | func (b *BitSet) Clone() *BitSet {
c := New(b.length)
if b.set != nil { // Clone should not modify current object
copy(c.set, b.set)
}
return c
} | go | {
"resource": ""
} |
q14331 | Copy | train | func (b *BitSet) Copy(c *BitSet) (count uint) {
if c == nil {
return
}
if b.set != nil { // Copy should not modify current object
copy(c.set, b.set)
}
count = c.length
if b.length < c.length {
count = b.length
}
return
} | go | {
"resource": ""
} |
q14332 | Equal | train | func (b *BitSet) Equal(c *BitSet) bool {
if c == nil {
return false
}
if b.length != c.length {
return false
}
if b.length == 0 { // if they have both length == 0, then could have nil set
return true
}
// testing for equality shoud not transform the bitset (no call to safeSet)
for p, v := range b.set {
... | go | {
"resource": ""
} |
q14333 | DifferenceCardinality | train | func (b *BitSet) DifferenceCardinality(compare *BitSet) uint {
panicIfNull(b)
panicIfNull(compare)
l := int(compare.wordCount())
if l > int(b.wordCount()) {
l = int(b.wordCount())
}
cnt := uint64(0)
cnt += popcntMaskSlice(b.set[:l], compare.set[:l])
cnt += popcntSlice(b.set[l:])
return uint(cnt)
} | go | {
"resource": ""
} |
q14334 | IntersectionCardinality | train | func (b *BitSet) IntersectionCardinality(compare *BitSet) uint {
panicIfNull(b)
panicIfNull(compare)
b, compare = sortByLength(b, compare)
cnt := popcntAndSlice(b.set, compare.set)
return uint(cnt)
} | go | {
"resource": ""
} |
q14335 | UnionCardinality | train | func (b *BitSet) UnionCardinality(compare *BitSet) uint {
panicIfNull(b)
panicIfNull(compare)
b, compare = sortByLength(b, compare)
cnt := popcntOrSlice(b.set, compare.set)
if len(compare.set) > len(b.set) {
cnt += popcntSlice(compare.set[len(b.set):])
}
return uint(cnt)
} | go | {
"resource": ""
} |
q14336 | SymmetricDifferenceCardinality | train | func (b *BitSet) SymmetricDifferenceCardinality(compare *BitSet) uint {
panicIfNull(b)
panicIfNull(compare)
b, compare = sortByLength(b, compare)
cnt := popcntXorSlice(b.set, compare.set)
if len(compare.set) > len(b.set) {
cnt += popcntSlice(compare.set[len(b.set):])
}
return uint(cnt)
} | go | {
"resource": ""
} |
q14337 | cleanLastWord | train | func (b *BitSet) cleanLastWord() {
if !b.isLenExactMultiple() {
b.set[len(b.set)-1] &= allBits >> (wordSize - b.length%wordSize)
}
} | go | {
"resource": ""
} |
q14338 | All | train | func (b *BitSet) All() bool {
panicIfNull(b)
return b.Count() == b.length
} | go | {
"resource": ""
} |
q14339 | None | train | func (b *BitSet) None() bool {
panicIfNull(b)
if b != nil && b.set != nil {
for _, word := range b.set {
if word > 0 {
return false
}
}
return true
}
return true
} | go | {
"resource": ""
} |
q14340 | IsSuperSet | train | func (b *BitSet) IsSuperSet(other *BitSet) bool {
for i, e := other.NextSet(0); e; i, e = other.NextSet(i + 1) {
if !b.Test(i) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14341 | IsStrictSuperSet | train | func (b *BitSet) IsStrictSuperSet(other *BitSet) bool {
return b.Count() > other.Count() && b.IsSuperSet(other)
} | go | {
"resource": ""
} |
q14342 | DumpAsBits | train | func (b *BitSet) DumpAsBits() string {
if b.set == nil {
return "."
}
buffer := bytes.NewBufferString("")
i := len(b.set) - 1
for ; i >= 0; i-- {
fmt.Fprintf(buffer, "%064b.", b.set[i])
}
return buffer.String()
} | go | {
"resource": ""
} |
q14343 | BinaryStorageSize | train | func (b *BitSet) BinaryStorageSize() int {
return binary.Size(uint64(0)) + binary.Size(b.set)
} | go | {
"resource": ""
} |
q14344 | WriteTo | train | func (b *BitSet) WriteTo(stream io.Writer) (int64, error) {
length := uint64(b.length)
// Write length
err := binary.Write(stream, binaryOrder, length)
if err != nil {
return 0, err
}
// Write set
err = binary.Write(stream, binaryOrder, b.set)
return int64(b.BinaryStorageSize()), err
} | go | {
"resource": ""
} |
q14345 | ReadFrom | train | func (b *BitSet) ReadFrom(stream io.Reader) (int64, error) {
var length uint64
// Read length first
err := binary.Read(stream, binaryOrder, &length)
if err != nil {
return 0, err
}
newset := New(uint(length))
if uint64(newset.length) != length {
return 0, errors.New("Unmarshalling error: type mismatch")
}... | go | {
"resource": ""
} |
q14346 | MarshalBinary | train | func (b *BitSet) MarshalBinary() ([]byte, error) {
var buf bytes.Buffer
writer := bufio.NewWriter(&buf)
_, err := b.WriteTo(writer)
if err != nil {
return []byte{}, err
}
err = writer.Flush()
return buf.Bytes(), err
} | go | {
"resource": ""
} |
q14347 | UnmarshalBinary | train | func (b *BitSet) UnmarshalBinary(data []byte) error {
buf := bytes.NewReader(data)
reader := bufio.NewReader(buf)
_, err := b.ReadFrom(reader)
return err
} | go | {
"resource": ""
} |
q14348 | MarshalJSON | train | func (b *BitSet) MarshalJSON() ([]byte, error) {
buffer := bytes.NewBuffer(make([]byte, 0, b.BinaryStorageSize()))
_, err := b.WriteTo(buffer)
if err != nil {
return nil, err
}
// URLEncode all bytes
return json.Marshal(base64Encoding.EncodeToString(buffer.Bytes()))
} | go | {
"resource": ""
} |
q14349 | UnmarshalJSON | train | func (b *BitSet) UnmarshalJSON(data []byte) error {
// Unmarshal as string
var s string
err := json.Unmarshal(data, &s)
if err != nil {
return err
}
// URLDecode string
buf, err := base64Encoding.DecodeString(s)
if err != nil {
return err
}
_, err = b.ReadFrom(bytes.NewReader(buf))
return err
} | go | {
"resource": ""
} |
q14350 | Get | train | func (p *Pool) Get() *ByteBuffer {
v := p.pool.Get()
if v != nil {
return v.(*ByteBuffer)
}
return &ByteBuffer{
B: make([]byte, 0, atomic.LoadUint64(&p.defaultSize)),
}
} | go | {
"resource": ""
} |
q14351 | Put | train | func (p *Pool) Put(b *ByteBuffer) {
idx := index(len(b.B))
if atomic.AddUint64(&p.calls[idx], 1) > calibrateCallsThreshold {
p.calibrate()
}
maxSize := int(atomic.LoadUint64(&p.maxSize))
if maxSize == 0 || cap(b.B) <= maxSize {
b.Reset()
p.pool.Put(b)
}
} | go | {
"resource": ""
} |
q14352 | ReadFrom | train | func (b *ByteBuffer) ReadFrom(r io.Reader) (int64, error) {
p := b.B
nStart := int64(len(p))
nMax := int64(cap(p))
n := nStart
if nMax == 0 {
nMax = 64
p = make([]byte, nMax)
} else {
p = p[:nMax]
}
for {
if n == nMax {
nMax *= 2
bNew := make([]byte, nMax)
copy(bNew, p)
p = bNew
}
nn, er... | go | {
"resource": ""
} |
q14353 | WriteTo | train | func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write(b.B)
return int64(n), err
} | go | {
"resource": ""
} |
q14354 | Write | train | func (b *ByteBuffer) Write(p []byte) (int, error) {
b.B = append(b.B, p...)
return len(p), nil
} | go | {
"resource": ""
} |
q14355 | WriteByte | train | func (b *ByteBuffer) WriteByte(c byte) error {
b.B = append(b.B, c)
return nil
} | go | {
"resource": ""
} |
q14356 | WriteString | train | func (b *ByteBuffer) WriteString(s string) (int, error) {
b.B = append(b.B, s...)
return len(s), nil
} | go | {
"resource": ""
} |
q14357 | Set | train | func (b *ByteBuffer) Set(p []byte) {
b.B = append(b.B[:0], p...)
} | go | {
"resource": ""
} |
q14358 | SetString | train | func (b *ByteBuffer) SetString(s string) {
b.B = append(b.B[:0], s...)
} | go | {
"resource": ""
} |
q14359 | Print | train | func Print(a ...interface{}) (int, error) {
return fmt.Print(compile(fmt.Sprint(a...)))
} | go | {
"resource": ""
} |
q14360 | Println | train | func Println(a ...interface{}) (int, error) {
return fmt.Println(compile(fmt.Sprint(a...)))
} | go | {
"resource": ""
} |
q14361 | Fprint | train | func Fprint(w io.Writer, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprint(a...)))
} | go | {
"resource": ""
} |
q14362 | Fprintf | train | func Fprintf(w io.Writer, format string, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q14363 | Sprintf | train | func Sprintf(format string, a ...interface{}) string {
return compile(fmt.Sprintf(format, a...))
} | go | {
"resource": ""
} |
q14364 | Errorf | train | func Errorf(format string, a ...interface{}) error {
return errors.New(compile(Sprintf(format, a...)))
} | go | {
"resource": ""
} |
q14365 | InitConfigLinuxResourcesCPU | train | func (g *Generator) InitConfigLinuxResourcesCPU() {
g.initConfigLinuxResources()
if g.Config.Linux.Resources.CPU == nil {
g.Config.Linux.Resources.CPU = &rspec.LinuxCPU{}
}
} | go | {
"resource": ""
} |
q14366 | GetPidsData | train | func (cg *CgroupV1) GetPidsData(pid int, cgPath string) (*rspec.LinuxPids, error) {
if filepath.IsAbs(cgPath) {
path := filepath.Join(cg.MountPath, "pids", cgPath)
if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
return nil, specerror.NewError(specerror.CgroupsAbsPathRelToMount, fmt.Errorf("... | go | {
"resource": ""
} |
q14367 | decideCourseOfAction | train | func decideCourseOfAction(newSyscall *rspec.LinuxSyscall, syscalls []rspec.LinuxSyscall) (string, error) {
ruleForSyscallAlreadyExists := false
var sliceOfDeterminedActions []string
for i, syscall := range syscalls {
if sameName(&syscall, newSyscall) {
ruleForSyscallAlreadyExists = true
if identical(newSys... | go | {
"resource": ""
} |
q14368 | GetPidsData | train | func GetPidsData(pid int, cgPath string) (*rspec.LinuxPids, error) {
return nil, fmt.Errorf("unimplemented yet")
} | go | {
"resource": ""
} |
q14369 | LastCap | train | func LastCap() capability.Cap {
last := capability.CAP_LAST_CAP
// hack for RHEL6 which has no /proc/sys/kernel/cap_last_cap
if last == capability.Cap(63) {
last = capability.CAP_BLOCK_SUSPEND
}
return last
} | go | {
"resource": ""
} |
q14370 | RemoveAllSeccompRules | train | func RemoveAllSeccompRules(config *rspec.LinuxSeccomp) error {
if config == nil {
return fmt.Errorf("Cannot remove action from nil Seccomp pointer")
}
newSyscallSlice := []rspec.LinuxSyscall{}
config.Syscalls = newSyscallSlice
return nil
} | go | {
"resource": ""
} |
q14371 | RemoveAllMatchingRules | train | func RemoveAllMatchingRules(config *rspec.LinuxSeccomp, seccompAction rspec.LinuxSeccompAction) error {
if config == nil {
return fmt.Errorf("Cannot remove action from nil Seccomp pointer")
}
for _, syscall := range config.Syscalls {
if reflect.DeepEqual(syscall.Action, seccompAction) {
RemoveAction(strings.... | go | {
"resource": ""
} |
q14372 | FindCgroup | train | func FindCgroup() (Cgroup, error) {
f, err := os.Open("/proc/self/mountinfo")
if err != nil {
return nil, err
}
defer f.Close()
cgroupv2 := false
scanner := bufio.NewScanner(f)
for scanner.Scan() {
text := scanner.Text()
fields := strings.Split(text, " ")
// Safe as mountinfo encodes mountpoints with sp... | go | {
"resource": ""
} |
q14373 | GetSubsystemPath | train | func GetSubsystemPath(pid int, subsystem string) (string, error) {
contents, err := ioutil.ReadFile(fmt.Sprintf("/proc/%d/cgroup", pid))
if err != nil {
return "", err
}
parts := strings.Split(strings.TrimSpace(string(contents)), "\n")
for _, part := range parts {
elem := strings.SplitN(part, ":", 3)
if len... | go | {
"resource": ""
} |
q14374 | NewFromFile | train | func NewFromFile(path string) (Generator, error) {
cf, err := os.Open(path)
if err != nil {
if os.IsNotExist(err) {
return Generator{}, fmt.Errorf("template configuration at %s not found", path)
}
return Generator{}, err
}
defer cf.Close()
return NewFromTemplate(cf)
} | go | {
"resource": ""
} |
q14375 | NewFromTemplate | train | func NewFromTemplate(r io.Reader) (Generator, error) {
var config rspec.Spec
if err := json.NewDecoder(r).Decode(&config); err != nil {
return Generator{}, err
}
envCache := map[string]int{}
if config.Process != nil {
envCache = createEnvCacheMap(config.Process.Env)
}
return Generator{
Config: &config,
... | go | {
"resource": ""
} |
q14376 | createEnvCacheMap | train | func createEnvCacheMap(env []string) map[string]int {
envMap := make(map[string]int, len(env))
for i, val := range env {
envMap[val] = i
}
return envMap
} | go | {
"resource": ""
} |
q14377 | Save | train | func (g *Generator) Save(w io.Writer, exportOpts ExportOptions) (err error) {
var data []byte
if g.Config.Linux != nil {
buf, err := json.Marshal(g.Config.Linux)
if err != nil {
return err
}
if string(buf) == "{}" {
g.Config.Linux = nil
}
}
if exportOpts.Seccomp {
data, err = json.MarshalIndent(... | go | {
"resource": ""
} |
q14378 | SaveToFile | train | func (g *Generator) SaveToFile(path string, exportOpts ExportOptions) error {
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
return g.Save(f, exportOpts)
} | go | {
"resource": ""
} |
q14379 | SetVersion | train | func (g *Generator) SetVersion(version string) {
g.initConfig()
g.Config.Version = version
} | go | {
"resource": ""
} |
q14380 | SetRootPath | train | func (g *Generator) SetRootPath(path string) {
g.initConfigRoot()
g.Config.Root.Path = path
} | go | {
"resource": ""
} |
q14381 | SetRootReadonly | train | func (g *Generator) SetRootReadonly(b bool) {
g.initConfigRoot()
g.Config.Root.Readonly = b
} | go | {
"resource": ""
} |
q14382 | SetHostname | train | func (g *Generator) SetHostname(s string) {
g.initConfig()
g.Config.Hostname = s
} | go | {
"resource": ""
} |
q14383 | SetOCIVersion | train | func (g *Generator) SetOCIVersion(s string) {
g.initConfig()
g.Config.Version = s
} | go | {
"resource": ""
} |
q14384 | ClearAnnotations | train | func (g *Generator) ClearAnnotations() {
if g.Config == nil {
return
}
g.Config.Annotations = make(map[string]string)
} | go | {
"resource": ""
} |
q14385 | AddAnnotation | train | func (g *Generator) AddAnnotation(key, value string) {
g.initConfigAnnotations()
g.Config.Annotations[key] = value
} | go | {
"resource": ""
} |
q14386 | RemoveAnnotation | train | func (g *Generator) RemoveAnnotation(key string) {
if g.Config == nil || g.Config.Annotations == nil {
return
}
delete(g.Config.Annotations, key)
} | go | {
"resource": ""
} |
q14387 | SetProcessConsoleSize | train | func (g *Generator) SetProcessConsoleSize(width, height uint) {
g.initConfigProcessConsoleSize()
g.Config.Process.ConsoleSize.Width = width
g.Config.Process.ConsoleSize.Height = height
} | go | {
"resource": ""
} |
q14388 | SetProcessUID | train | func (g *Generator) SetProcessUID(uid uint32) {
g.initConfigProcess()
g.Config.Process.User.UID = uid
} | go | {
"resource": ""
} |
q14389 | SetProcessUsername | train | func (g *Generator) SetProcessUsername(username string) {
g.initConfigProcess()
g.Config.Process.User.Username = username
} | go | {
"resource": ""
} |
q14390 | SetProcessGID | train | func (g *Generator) SetProcessGID(gid uint32) {
g.initConfigProcess()
g.Config.Process.User.GID = gid
} | go | {
"resource": ""
} |
q14391 | SetProcessCwd | train | func (g *Generator) SetProcessCwd(cwd string) {
g.initConfigProcess()
g.Config.Process.Cwd = cwd
} | go | {
"resource": ""
} |
q14392 | SetProcessNoNewPrivileges | train | func (g *Generator) SetProcessNoNewPrivileges(b bool) {
g.initConfigProcess()
g.Config.Process.NoNewPrivileges = b
} | go | {
"resource": ""
} |
q14393 | SetProcessTerminal | train | func (g *Generator) SetProcessTerminal(b bool) {
g.initConfigProcess()
g.Config.Process.Terminal = b
} | go | {
"resource": ""
} |
q14394 | SetProcessApparmorProfile | train | func (g *Generator) SetProcessApparmorProfile(prof string) {
g.initConfigProcess()
g.Config.Process.ApparmorProfile = prof
} | go | {
"resource": ""
} |
q14395 | SetProcessArgs | train | func (g *Generator) SetProcessArgs(args []string) {
g.initConfigProcess()
g.Config.Process.Args = args
} | go | {
"resource": ""
} |
q14396 | ClearProcessEnv | train | func (g *Generator) ClearProcessEnv() {
if g.Config == nil || g.Config.Process == nil {
return
}
g.Config.Process.Env = []string{}
// Clear out the env cache map as well
g.envMap = map[string]int{}
} | go | {
"resource": ""
} |
q14397 | AddProcessEnv | train | func (g *Generator) AddProcessEnv(name, value string) {
if name == "" {
return
}
g.initConfigProcess()
g.addEnv(fmt.Sprintf("%s=%s", name, value), name)
} | go | {
"resource": ""
} |
q14398 | AddMultipleProcessEnv | train | func (g *Generator) AddMultipleProcessEnv(envs []string) {
g.initConfigProcess()
for _, val := range envs {
split := strings.SplitN(val, "=", 2)
g.addEnv(val, split[0])
}
} | go | {
"resource": ""
} |
q14399 | addEnv | train | func (g *Generator) addEnv(env, key string) {
if idx, ok := g.envMap[key]; ok {
// The ENV exists in the cache, so change its value in g.Config.Process.Env
g.Config.Process.Env[idx] = env
} else {
// else the env doesn't exist, so add it and add it's index to g.envMap
g.Config.Process.Env = append(g.Config.Pr... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.