id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
14,300 | go-ozzo/ozzo-routing | context.go | PostForm | 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 | 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 ""
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"PostForm",
"(",
"key",
"string",
",",
"defaultValue",
"...",
"string",
")",
"string",
"{",
"r",
":=",
"c",
".",
"Request",
"\n",
"r",
".",
"ParseMultipartForm",
"(",
"32",
"<<",
"20",
")",
"\n",
"if",
"vs",
"... | // PostForm returns the first value for the named component from POST and PUT body parameters.
// If key is not present, it returns the specified default value or an empty string. | [
"PostForm",
"returns",
"the",
"first",
"value",
"for",
"the",
"named",
"component",
"from",
"POST",
"and",
"PUT",
"body",
"parameters",
".",
"If",
"key",
"is",
"not",
"present",
"it",
"returns",
"the",
"specified",
"default",
"value",
"or",
"an",
"empty",
... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L106-L117 |
14,301 | go-ozzo/ozzo-routing | context.go | Next | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Next",
"(",
")",
"error",
"{",
"c",
".",
"index",
"++",
"\n",
"for",
"n",
":=",
"len",
"(",
"c",
".",
"handlers",
")",
";",
"c",
".",
"index",
"<",
"n",
";",
"c",
".",
"index",
"++",
"{",
"if",
"err",... | // Next calls the rest of the handlers associated with the current route.
// If any of these handlers returns an error, Next will return the error and skip the following handlers.
// Next is normally used when a handler needs to do some postprocessing after the rest of the handlers
// are executed. | [
"Next",
"calls",
"the",
"rest",
"of",
"the",
"handlers",
"associated",
"with",
"the",
"current",
"route",
".",
"If",
"any",
"of",
"these",
"handlers",
"returns",
"an",
"error",
"Next",
"will",
"return",
"the",
"error",
"and",
"skip",
"the",
"following",
"h... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L123-L131 |
14,302 | go-ozzo/ozzo-routing | context.go | Read | 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 | 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)
} | [
"func",
"(",
"c",
"*",
"Context",
")",
"Read",
"(",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"c",
".",
"Request",
".",
"Method",
"!=",
"\"",
"\"",
"{",
"t",
":=",
"getContentType",
"(",
"c",
".",
"Request",
")",
"\n",
"if",
"reader... | // Read populates the given struct variable with the data from the current request.
// If the request is NOT a GET request, it will check the "Content-Type" header
// and find a matching reader from DataReaders to read the request data.
// If there is no match or if the request is a GET request, it will use DefaultFormDataReader
// to read the request data. | [
"Read",
"populates",
"the",
"given",
"struct",
"variable",
"with",
"the",
"data",
"from",
"the",
"current",
"request",
".",
"If",
"the",
"request",
"is",
"NOT",
"a",
"GET",
"request",
"it",
"will",
"check",
"the",
"Content",
"-",
"Type",
"header",
"and",
... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/context.go#L157-L166 |
14,303 | go-ozzo/ozzo-routing | content/language.go | negotiateLanguage | 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) {
bestQ = spec.Q
bestOffer = offer
}
}
}
if bestQ == 0 {
bestOffer = defaultOffer
}
return bestOffer
} | go | 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) {
bestQ = spec.Q
bestOffer = offer
}
}
}
if bestQ == 0 {
bestOffer = defaultOffer
}
return bestOffer
} | [
"func",
"negotiateLanguage",
"(",
"r",
"*",
"http",
".",
"Request",
",",
"offers",
"[",
"]",
"string",
",",
"defaultOffer",
"string",
")",
"string",
"{",
"bestOffer",
":=",
"defaultOffer",
"\n",
"bestQ",
":=",
"-",
"1.0",
"\n",
"specs",
":=",
"header",
"... | // negotiateLanguage negotiates the acceptable language according to the Accept-Language HTTP header. | [
"negotiateLanguage",
"negotiates",
"the",
"acceptable",
"language",
"according",
"to",
"the",
"Accept",
"-",
"Language",
"HTTP",
"header",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/content/language.go#L44-L60 |
14,304 | go-ozzo/ozzo-routing | reader.go | ReadFormData | 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 readForm(form, "", rv)
} | go | 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 readForm(form, "", rv)
} | [
"func",
"ReadFormData",
"(",
"form",
"map",
"[",
"string",
"]",
"[",
"]",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"error",
"{",
"rv",
":=",
"reflect",
".",
"ValueOf",
"(",
"data",
")",
"\n",
"if",
"rv",
".",
"Kind",
"(",
")",
"!=",
"re... | // ReadFormData populates the data variable with the data from the given form values. | [
"ReadFormData",
"populates",
"the",
"data",
"variable",
"with",
"the",
"data",
"from",
"the",
"given",
"form",
"values",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/reader.go#L76-L87 |
14,305 | go-ozzo/ozzo-routing | auth/handlers.go | DefaultJWTTokenHandler | func DefaultJWTTokenHandler(c *routing.Context, token *jwt.Token) error {
c.Set("JWT", token)
return nil
} | go | func DefaultJWTTokenHandler(c *routing.Context, token *jwt.Token) error {
c.Set("JWT", token)
return nil
} | [
"func",
"DefaultJWTTokenHandler",
"(",
"c",
"*",
"routing",
".",
"Context",
",",
"token",
"*",
"jwt",
".",
"Token",
")",
"error",
"{",
"c",
".",
"Set",
"(",
"\"",
"\"",
",",
"token",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // DefaultJWTTokenHandler stores the parsed JWT token in the routing context with the key named "JWT". | [
"DefaultJWTTokenHandler",
"stores",
"the",
"parsed",
"JWT",
"token",
"in",
"the",
"routing",
"context",
"with",
"the",
"key",
"named",
"JWT",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/auth/handlers.go#L208-L211 |
14,306 | go-ozzo/ozzo-routing | auth/handlers.go | NewJWT | 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 | 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))
} | [
"func",
"NewJWT",
"(",
"claims",
"jwt",
".",
"MapClaims",
",",
"signingKey",
"string",
",",
"signingMethod",
"...",
"jwt",
".",
"SigningMethod",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"sm",
"jwt",
".",
"SigningMethod",
"=",
"jwt",
".",
"Signi... | // NewJWT creates a new JWT token and returns it as a signed string that may be sent to the client side.
// The signingMethod parameter is optional. It defaults to the HS256 algorithm. | [
"NewJWT",
"creates",
"a",
"new",
"JWT",
"token",
"and",
"returns",
"it",
"as",
"a",
"signed",
"string",
"that",
"may",
"be",
"sent",
"to",
"the",
"client",
"side",
".",
"The",
"signingMethod",
"parameter",
"is",
"optional",
".",
"It",
"defaults",
"to",
"... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/auth/handlers.go#L298-L304 |
14,307 | go-ozzo/ozzo-routing | router.go | New | 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.maxParams),
router: r,
}
}
return r
} | go | 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.maxParams),
router: r,
}
}
return r
} | [
"func",
"New",
"(",
")",
"*",
"Router",
"{",
"r",
":=",
"&",
"Router",
"{",
"namedRoutes",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Route",
")",
",",
"stores",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"routeStore",
")",
",",
"}",
... | // New creates a new Router object. | [
"New",
"creates",
"a",
"new",
"Router",
"object",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L56-L70 |
14,308 | go-ozzo/ozzo-routing | router.go | ServeHTTP | 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)
}
} else {
c.handlers, c.pnames = r.find(req.Method, r.normalizeRequestPath(req.URL.Path), c.pvalues)
}
if err := c.Next(); err != nil {
r.handleError(c, err)
}
r.pool.Put(c)
} | go | 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)
}
} else {
c.handlers, c.pnames = r.find(req.Method, r.normalizeRequestPath(req.URL.Path), c.pvalues)
}
if err := c.Next(); err != nil {
r.handleError(c, err)
}
r.pool.Put(c)
} | [
"func",
"(",
"r",
"*",
"Router",
")",
"ServeHTTP",
"(",
"res",
"http",
".",
"ResponseWriter",
",",
"req",
"*",
"http",
".",
"Request",
")",
"{",
"c",
":=",
"r",
".",
"pool",
".",
"Get",
"(",
")",
".",
"(",
"*",
"Context",
")",
"\n",
"c",
".",
... | // ServeHTTP handles the HTTP request.
// It is required by http.Handler | [
"ServeHTTP",
"handles",
"the",
"HTTP",
"request",
".",
"It",
"is",
"required",
"by",
"http",
".",
"Handler"
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L74-L89 |
14,309 | go-ozzo/ozzo-routing | router.go | Use | func (r *Router) Use(handlers ...Handler) {
r.RouteGroup.Use(handlers...)
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | go | func (r *Router) Use(handlers ...Handler) {
r.RouteGroup.Use(handlers...)
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | [
"func",
"(",
"r",
"*",
"Router",
")",
"Use",
"(",
"handlers",
"...",
"Handler",
")",
"{",
"r",
".",
"RouteGroup",
".",
"Use",
"(",
"handlers",
"...",
")",
"\n",
"r",
".",
"notFoundHandlers",
"=",
"combineHandlers",
"(",
"r",
".",
"handlers",
",",
"r"... | // Use appends the specified handlers to the router and shares them with all routes. | [
"Use",
"appends",
"the",
"specified",
"handlers",
"to",
"the",
"router",
"and",
"shares",
"them",
"with",
"all",
"routes",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L103-L106 |
14,310 | go-ozzo/ozzo-routing | router.go | NotFound | func (r *Router) NotFound(handlers ...Handler) {
r.notFound = handlers
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | go | func (r *Router) NotFound(handlers ...Handler) {
r.notFound = handlers
r.notFoundHandlers = combineHandlers(r.handlers, r.notFound)
} | [
"func",
"(",
"r",
"*",
"Router",
")",
"NotFound",
"(",
"handlers",
"...",
"Handler",
")",
"{",
"r",
".",
"notFound",
"=",
"handlers",
"\n",
"r",
".",
"notFoundHandlers",
"=",
"combineHandlers",
"(",
"r",
".",
"handlers",
",",
"r",
".",
"notFound",
")",... | // NotFound specifies the handlers that should be invoked when the router cannot find any route matching a request.
// Note that the handlers registered via Use will be invoked first in this case. | [
"NotFound",
"specifies",
"the",
"handlers",
"that",
"should",
"be",
"invoked",
"when",
"the",
"router",
"cannot",
"find",
"any",
"route",
"matching",
"a",
"request",
".",
"Note",
"that",
"the",
"handlers",
"registered",
"via",
"Use",
"will",
"be",
"invoked",
... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L110-L113 |
14,311 | go-ozzo/ozzo-routing | router.go | Find | 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 | 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
} | [
"func",
"(",
"r",
"*",
"Router",
")",
"Find",
"(",
"method",
",",
"path",
"string",
")",
"(",
"handlers",
"[",
"]",
"Handler",
",",
"params",
"map",
"[",
"string",
"]",
"string",
")",
"{",
"pvalues",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"r... | // Find determines the handlers and parameters to use for a specified method and path. | [
"Find",
"determines",
"the",
"handlers",
"and",
"parameters",
"to",
"use",
"for",
"a",
"specified",
"method",
"and",
"path",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L116-L124 |
14,312 | go-ozzo/ozzo-routing | router.go | HTTPHandlerFunc | func HTTPHandlerFunc(h http.HandlerFunc) Handler {
return func(c *Context) error {
h(c.Response, c.Request)
return nil
}
} | go | func HTTPHandlerFunc(h http.HandlerFunc) Handler {
return func(c *Context) error {
h(c.Response, c.Request)
return nil
}
} | [
"func",
"HTTPHandlerFunc",
"(",
"h",
"http",
".",
"HandlerFunc",
")",
"Handler",
"{",
"return",
"func",
"(",
"c",
"*",
"Context",
")",
"error",
"{",
"h",
"(",
"c",
".",
"Response",
",",
"c",
".",
"Request",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\... | // HTTPHandlerFunc adapts a http.HandlerFunc into a routing.Handler. | [
"HTTPHandlerFunc",
"adapts",
"a",
"http",
".",
"HandlerFunc",
"into",
"a",
"routing",
".",
"Handler",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/router.go#L220-L225 |
14,313 | go-ozzo/ozzo-routing | store.go | newStore | func newStore() *store {
return &store{
root: &node{
static: true,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: -1,
pnames: []string{},
},
}
} | go | func newStore() *store {
return &store{
root: &node{
static: true,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: -1,
pnames: []string{},
},
}
} | [
"func",
"newStore",
"(",
")",
"*",
"store",
"{",
"return",
"&",
"store",
"{",
"root",
":",
"&",
"node",
"{",
"static",
":",
"true",
",",
"children",
":",
"make",
"(",
"[",
"]",
"*",
"node",
",",
"256",
")",
",",
"pchildren",
":",
"make",
"(",
"... | // newStore creates a new store. | [
"newStore",
"creates",
"a",
"new",
"store",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L24-L34 |
14,314 | go-ozzo/ozzo-routing | store.go | Add | func (s *store) Add(key string, data interface{}) int {
s.count++
return s.root.add(key, data, s.count)
} | go | func (s *store) Add(key string, data interface{}) int {
s.count++
return s.root.add(key, data, s.count)
} | [
"func",
"(",
"s",
"*",
"store",
")",
"Add",
"(",
"key",
"string",
",",
"data",
"interface",
"{",
"}",
")",
"int",
"{",
"s",
".",
"count",
"++",
"\n",
"return",
"s",
".",
"root",
".",
"add",
"(",
"key",
",",
"data",
",",
"s",
".",
"count",
")"... | // Add adds a new data item with the given parametric key.
// The number of parameters in the key is returned. | [
"Add",
"adds",
"a",
"new",
"data",
"item",
"with",
"the",
"given",
"parametric",
"key",
".",
"The",
"number",
"of",
"parameters",
"in",
"the",
"key",
"is",
"returned",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L38-L41 |
14,315 | go-ozzo/ozzo-routing | store.go | Get | func (s *store) Get(path string, pvalues []string) (data interface{}, pnames []string) {
data, pnames, _ = s.root.get(path, pvalues)
return
} | go | func (s *store) Get(path string, pvalues []string) (data interface{}, pnames []string) {
data, pnames, _ = s.root.get(path, pvalues)
return
} | [
"func",
"(",
"s",
"*",
"store",
")",
"Get",
"(",
"path",
"string",
",",
"pvalues",
"[",
"]",
"string",
")",
"(",
"data",
"interface",
"{",
"}",
",",
"pnames",
"[",
"]",
"string",
")",
"{",
"data",
",",
"pnames",
",",
"_",
"=",
"s",
".",
"root",... | // Get returns the data item matching the given concrete key.
// If the data item was added to the store with a parametric key before, the matching
// parameter names and values will be returned as well. | [
"Get",
"returns",
"the",
"data",
"item",
"matching",
"the",
"given",
"concrete",
"key",
".",
"If",
"the",
"data",
"item",
"was",
"added",
"to",
"the",
"store",
"with",
"a",
"parametric",
"key",
"before",
"the",
"matching",
"parameter",
"names",
"and",
"val... | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L46-L49 |
14,316 | go-ozzo/ozzo-routing | store.go | add | 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 key: make the current node as data node
// if the node is already a data node, ignore the new data since we only care the first matched node
if n.data == nil {
n.data = data
n.order = order
}
return n.pindex + 1
}
// the node key is a prefix of the key: create a child node
newKey := key[matched:]
// try adding to a static child
if child := n.children[newKey[0]]; child != nil {
if pn := child.add(newKey, data, order); pn >= 0 {
return pn
}
}
// try adding to a param child
for _, child := range n.pchildren {
if pn := child.add(newKey, data, order); pn >= 0 {
return pn
}
}
return n.addChild(newKey, data, order)
}
if matched == 0 || !n.static {
// no common prefix, or partial common prefix with a non-static node: should skip this node
return -1
}
// the node key shares a partial prefix with the key: split the node key
n1 := &node{
static: true,
key: n.key[matched:],
data: n.data,
order: n.order,
minOrder: n.minOrder,
pchildren: n.pchildren,
children: n.children,
pindex: n.pindex,
pnames: n.pnames,
}
n.key = key[0:matched]
n.data = nil
n.pchildren = make([]*node, 0)
n.children = make([]*node, 256)
n.children[n1.key[0]] = n1
return n.add(key, data, order)
} | go | 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 key: make the current node as data node
// if the node is already a data node, ignore the new data since we only care the first matched node
if n.data == nil {
n.data = data
n.order = order
}
return n.pindex + 1
}
// the node key is a prefix of the key: create a child node
newKey := key[matched:]
// try adding to a static child
if child := n.children[newKey[0]]; child != nil {
if pn := child.add(newKey, data, order); pn >= 0 {
return pn
}
}
// try adding to a param child
for _, child := range n.pchildren {
if pn := child.add(newKey, data, order); pn >= 0 {
return pn
}
}
return n.addChild(newKey, data, order)
}
if matched == 0 || !n.static {
// no common prefix, or partial common prefix with a non-static node: should skip this node
return -1
}
// the node key shares a partial prefix with the key: split the node key
n1 := &node{
static: true,
key: n.key[matched:],
data: n.data,
order: n.order,
minOrder: n.minOrder,
pchildren: n.pchildren,
children: n.children,
pindex: n.pindex,
pnames: n.pnames,
}
n.key = key[0:matched]
n.data = nil
n.pchildren = make([]*node, 0)
n.children = make([]*node, 256)
n.children[n1.key[0]] = n1
return n.add(key, data, order)
} | [
"func",
"(",
"n",
"*",
"node",
")",
"add",
"(",
"key",
"string",
",",
"data",
"interface",
"{",
"}",
",",
"order",
"int",
")",
"int",
"{",
"matched",
":=",
"0",
"\n\n",
"// find the common prefix",
"for",
";",
"matched",
"<",
"len",
"(",
"key",
")",
... | // add adds a new data item to the tree rooted at the current node.
// The number of parameters in the key is returned. | [
"add",
"adds",
"a",
"new",
"data",
"item",
"to",
"the",
"tree",
"rooted",
"at",
"the",
"current",
"node",
".",
"The",
"number",
"of",
"parameters",
"in",
"the",
"key",
"is",
"returned",
"."
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L76-L141 |
14,317 | go-ozzo/ozzo-routing | store.go | addChild | 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 token occurs after a static string, or no param token: create a static node
child := &node{
static: true,
key: key,
minOrder: order,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: n.pindex,
pnames: n.pnames,
}
n.children[key[0]] = child
if p1 > 0 {
// param token occurs after a static string
child.key = key[:p0]
n = child
} else {
// no param token: done adding the child
child.data = data
child.order = order
return child.pindex + 1
}
}
// add param node
child := &node{
static: false,
key: key[p0 : p1+1],
minOrder: order,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: n.pindex,
pnames: n.pnames,
}
pattern := ""
pname := key[p0+1 : p1]
for i := p0 + 1; i < p1; i++ {
if key[i] == ':' {
pname = key[p0+1 : i]
pattern = key[i+1 : p1]
break
}
}
if pattern != "" {
// the param token contains a regular expression
child.regex = regexp.MustCompile("^" + pattern)
}
pnames := make([]string, len(n.pnames)+1)
copy(pnames, n.pnames)
pnames[len(n.pnames)] = pname
child.pnames = pnames
child.pindex = len(pnames) - 1
n.pchildren = append(n.pchildren, child)
if p1 == len(key)-1 {
// the param token is at the end of the key
child.data = data
child.order = order
return child.pindex + 1
}
// process the rest of the key
return child.addChild(key[p1+1:], data, order)
} | go | 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 token occurs after a static string, or no param token: create a static node
child := &node{
static: true,
key: key,
minOrder: order,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: n.pindex,
pnames: n.pnames,
}
n.children[key[0]] = child
if p1 > 0 {
// param token occurs after a static string
child.key = key[:p0]
n = child
} else {
// no param token: done adding the child
child.data = data
child.order = order
return child.pindex + 1
}
}
// add param node
child := &node{
static: false,
key: key[p0 : p1+1],
minOrder: order,
children: make([]*node, 256),
pchildren: make([]*node, 0),
pindex: n.pindex,
pnames: n.pnames,
}
pattern := ""
pname := key[p0+1 : p1]
for i := p0 + 1; i < p1; i++ {
if key[i] == ':' {
pname = key[p0+1 : i]
pattern = key[i+1 : p1]
break
}
}
if pattern != "" {
// the param token contains a regular expression
child.regex = regexp.MustCompile("^" + pattern)
}
pnames := make([]string, len(n.pnames)+1)
copy(pnames, n.pnames)
pnames[len(n.pnames)] = pname
child.pnames = pnames
child.pindex = len(pnames) - 1
n.pchildren = append(n.pchildren, child)
if p1 == len(key)-1 {
// the param token is at the end of the key
child.data = data
child.order = order
return child.pindex + 1
}
// process the rest of the key
return child.addChild(key[p1+1:], data, order)
} | [
"func",
"(",
"n",
"*",
"node",
")",
"addChild",
"(",
"key",
"string",
",",
"data",
"interface",
"{",
"}",
",",
"order",
"int",
")",
"int",
"{",
"// find the first occurrence of a param token",
"p0",
",",
"p1",
":=",
"-",
"1",
",",
"-",
"1",
"\n",
"for"... | // addChild creates static and param nodes to store the given data | [
"addChild",
"creates",
"static",
"and",
"param",
"nodes",
"to",
"store",
"the",
"given",
"data"
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L144-L220 |
14,318 | go-ozzo/ozzo-routing | store.go | get | 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 := nkl - 1; i >= 0; i-- {
if n.key[i] != key[i] {
return
}
}
key = key[nkl:]
} else if n.regex != nil {
// param node with regular expression
if n.regex.String() == "^.*" {
pvalues[n.pindex] = key
key = ""
} else if match := n.regex.FindStringIndex(key); match != nil {
pvalues[n.pindex] = key[0:match[1]]
key = key[match[1]:]
} else {
return
}
} else {
// param node matching non-"/" characters
i, kl := 0, len(key)
for ; i < kl; i++ {
if key[i] == '/' {
pvalues[n.pindex] = key[0:i]
key = key[i:]
break
}
}
if i == kl {
pvalues[n.pindex] = key
key = ""
}
}
if len(key) > 0 {
// find a static child that can match the rest of the key
if child := n.children[key[0]]; child != nil {
if len(n.pchildren) == 0 {
// use goto to avoid recursion when no param children
n = child
goto repeat
}
data, pnames, order = child.get(key, pvalues)
}
} else if n.data != nil {
// do not return yet: a param node may match an empty string with smaller order
data, pnames, order = n.data, n.pnames, n.order
}
// try matching param children
tvalues := pvalues
allocated := false
for _, child := range n.pchildren {
if child.minOrder >= order {
continue
}
if data != nil && !allocated {
tvalues = make([]string, len(pvalues))
allocated = true
}
if d, p, s := child.get(key, tvalues); d != nil && s < order {
if allocated {
for i := child.pindex; i < len(p); i++ {
pvalues[i] = tvalues[i]
}
}
data, pnames, order = d, p, s
}
}
return
} | go | 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 := nkl - 1; i >= 0; i-- {
if n.key[i] != key[i] {
return
}
}
key = key[nkl:]
} else if n.regex != nil {
// param node with regular expression
if n.regex.String() == "^.*" {
pvalues[n.pindex] = key
key = ""
} else if match := n.regex.FindStringIndex(key); match != nil {
pvalues[n.pindex] = key[0:match[1]]
key = key[match[1]:]
} else {
return
}
} else {
// param node matching non-"/" characters
i, kl := 0, len(key)
for ; i < kl; i++ {
if key[i] == '/' {
pvalues[n.pindex] = key[0:i]
key = key[i:]
break
}
}
if i == kl {
pvalues[n.pindex] = key
key = ""
}
}
if len(key) > 0 {
// find a static child that can match the rest of the key
if child := n.children[key[0]]; child != nil {
if len(n.pchildren) == 0 {
// use goto to avoid recursion when no param children
n = child
goto repeat
}
data, pnames, order = child.get(key, pvalues)
}
} else if n.data != nil {
// do not return yet: a param node may match an empty string with smaller order
data, pnames, order = n.data, n.pnames, n.order
}
// try matching param children
tvalues := pvalues
allocated := false
for _, child := range n.pchildren {
if child.minOrder >= order {
continue
}
if data != nil && !allocated {
tvalues = make([]string, len(pvalues))
allocated = true
}
if d, p, s := child.get(key, tvalues); d != nil && s < order {
if allocated {
for i := child.pindex; i < len(p); i++ {
pvalues[i] = tvalues[i]
}
}
data, pnames, order = d, p, s
}
}
return
} | [
"func",
"(",
"n",
"*",
"node",
")",
"get",
"(",
"key",
"string",
",",
"pvalues",
"[",
"]",
"string",
")",
"(",
"data",
"interface",
"{",
"}",
",",
"pnames",
"[",
"]",
"string",
",",
"order",
"int",
")",
"{",
"order",
"=",
"math",
".",
"MaxInt32",... | // get returns the data item with the key matching the tree rooted at the current node | [
"get",
"returns",
"the",
"data",
"item",
"with",
"the",
"key",
"matching",
"the",
"tree",
"rooted",
"at",
"the",
"current",
"node"
] | 9dcabc145f0d565b5219e2fd72c3da04876980b7 | https://github.com/go-ozzo/ozzo-routing/blob/9dcabc145f0d565b5219e2fd72c3da04876980b7/store.go#L223-L304 |
14,319 | willf/bitset | bitset.go | safeSet | func (b *BitSet) safeSet() []uint64 {
if b.set == nil {
b.set = make([]uint64, wordsNeeded(0))
}
return b.set
} | go | func (b *BitSet) safeSet() []uint64 {
if b.set == nil {
b.set = make([]uint64, wordsNeeded(0))
}
return b.set
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"safeSet",
"(",
")",
"[",
"]",
"uint64",
"{",
"if",
"b",
".",
"set",
"==",
"nil",
"{",
"b",
".",
"set",
"=",
"make",
"(",
"[",
"]",
"uint64",
",",
"wordsNeeded",
"(",
"0",
")",
")",
"\n",
"}",
"\n",
"re... | // safeSet will fixup b.set to be non-nil and return the field value | [
"safeSet",
"will",
"fixup",
"b",
".",
"set",
"to",
"be",
"non",
"-",
"nil",
"and",
"return",
"the",
"field",
"value"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L83-L88 |
14,320 | willf/bitset | bitset.go | wordsNeeded | func wordsNeeded(i uint) int {
if i > (Cap() - wordSize + 1) {
return int(Cap() >> log2WordSize)
}
return int((i + (wordSize - 1)) >> log2WordSize)
} | go | func wordsNeeded(i uint) int {
if i > (Cap() - wordSize + 1) {
return int(Cap() >> log2WordSize)
}
return int((i + (wordSize - 1)) >> log2WordSize)
} | [
"func",
"wordsNeeded",
"(",
"i",
"uint",
")",
"int",
"{",
"if",
"i",
">",
"(",
"Cap",
"(",
")",
"-",
"wordSize",
"+",
"1",
")",
"{",
"return",
"int",
"(",
"Cap",
"(",
")",
">>",
"log2WordSize",
")",
"\n",
"}",
"\n",
"return",
"int",
"(",
"(",
... | // wordsNeeded calculates the number of words needed for i bits | [
"wordsNeeded",
"calculates",
"the",
"number",
"of",
"words",
"needed",
"for",
"i",
"bits"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L101-L106 |
14,321 | willf/bitset | bitset.go | New | 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 | 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
} | [
"func",
"New",
"(",
"length",
"uint",
")",
"(",
"bset",
"*",
"BitSet",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
"!=",
"nil",
"{",
"bset",
"=",
"&",
"BitSet",
"{",
"0",
",",
"make",
"(",
"[",
... | // New creates a new BitSet with a hint that length bits will be required | [
"New",
"creates",
"a",
"new",
"BitSet",
"with",
"a",
"hint",
"that",
"length",
"bits",
"will",
"be",
"required"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L109-L125 |
14,322 | willf/bitset | bitset.go | extendSetMaybe | 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, 2*nsize) // increase capacity 2x
copy(newset, b.set)
b.set = newset
}
b.length = i + 1
}
} | go | 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, 2*nsize) // increase capacity 2x
copy(newset, b.set)
b.set = newset
}
b.length = i + 1
}
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"extendSetMaybe",
"(",
"i",
"uint",
")",
"{",
"if",
"i",
">=",
"b",
".",
"length",
"{",
"// if we need more bits, make 'em",
"nsize",
":=",
"wordsNeeded",
"(",
"i",
"+",
"1",
")",
"\n",
"if",
"b",
".",
"set",
"==... | // extendSetMaybe adds additional words to incorporate new bits if needed | [
"extendSetMaybe",
"adds",
"additional",
"words",
"to",
"incorporate",
"new",
"bits",
"if",
"needed"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L138-L152 |
14,323 | willf/bitset | bitset.go | Set | func (b *BitSet) Set(i uint) *BitSet {
b.extendSetMaybe(i)
b.set[i>>log2WordSize] |= 1 << (i & (wordSize - 1))
return b
} | go | func (b *BitSet) Set(i uint) *BitSet {
b.extendSetMaybe(i)
b.set[i>>log2WordSize] |= 1 << (i & (wordSize - 1))
return b
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Set",
"(",
"i",
"uint",
")",
"*",
"BitSet",
"{",
"b",
".",
"extendSetMaybe",
"(",
"i",
")",
"\n",
"b",
".",
"set",
"[",
"i",
">>",
"log2WordSize",
"]",
"|=",
"1",
"<<",
"(",
"i",
"&",
"(",
"wordSize",
"-... | // Set bit i to 1 | [
"Set",
"bit",
"i",
"to",
"1"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L163-L167 |
14,324 | willf/bitset | bitset.go | Clear | func (b *BitSet) Clear(i uint) *BitSet {
if i >= b.length {
return b
}
b.set[i>>log2WordSize] &^= 1 << (i & (wordSize - 1))
return b
} | go | func (b *BitSet) Clear(i uint) *BitSet {
if i >= b.length {
return b
}
b.set[i>>log2WordSize] &^= 1 << (i & (wordSize - 1))
return b
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Clear",
"(",
"i",
"uint",
")",
"*",
"BitSet",
"{",
"if",
"i",
">=",
"b",
".",
"length",
"{",
"return",
"b",
"\n",
"}",
"\n",
"b",
".",
"set",
"[",
"i",
">>",
"log2WordSize",
"]",
"&^=",
"1",
"<<",
"(",
... | // Clear bit i to 0 | [
"Clear",
"bit",
"i",
"to",
"0"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L170-L176 |
14,325 | willf/bitset | bitset.go | SetTo | func (b *BitSet) SetTo(i uint, value bool) *BitSet {
if value {
return b.Set(i)
}
return b.Clear(i)
} | go | func (b *BitSet) SetTo(i uint, value bool) *BitSet {
if value {
return b.Set(i)
}
return b.Clear(i)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"SetTo",
"(",
"i",
"uint",
",",
"value",
"bool",
")",
"*",
"BitSet",
"{",
"if",
"value",
"{",
"return",
"b",
".",
"Set",
"(",
"i",
")",
"\n",
"}",
"\n",
"return",
"b",
".",
"Clear",
"(",
"i",
")",
"\n",
... | // SetTo sets bit i to value | [
"SetTo",
"sets",
"bit",
"i",
"to",
"value"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L179-L184 |
14,326 | willf/bitset | bitset.go | Flip | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Flip",
"(",
"i",
"uint",
")",
"*",
"BitSet",
"{",
"if",
"i",
">=",
"b",
".",
"length",
"{",
"return",
"b",
".",
"Set",
"(",
"i",
")",
"\n",
"}",
"\n",
"b",
".",
"set",
"[",
"i",
">>",
"log2WordSize",
"... | // Flip bit at i | [
"Flip",
"bit",
"at",
"i"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L187-L193 |
14,327 | willf/bitset | bitset.go | Shrink | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Shrink",
"(",
"length",
"uint",
")",
"*",
"BitSet",
"{",
"idx",
":=",
"wordsNeeded",
"(",
"length",
"+",
"1",
")",
"\n",
"if",
"idx",
">",
"len",
"(",
"b",
".",
"set",
")",
"{",
"return",
"b",
"\n",
"}",
... | // Shrink shrinks BitSet to desired length in bits. It clears all bits > length
// and reduces the size and length of the set.
//
// A new slice is allocated to store the new bits, so you may see an increase in
// memory usage until the GC runs. Normally this should not be a problem, but if you
// have an extremely large BitSet its important to understand that the old BitSet will
// remain in memory until the GC frees it. | [
"Shrink",
"shrinks",
"BitSet",
"to",
"desired",
"length",
"in",
"bits",
".",
"It",
"clears",
"all",
"bits",
">",
"length",
"and",
"reduces",
"the",
"size",
"and",
"length",
"of",
"the",
"set",
".",
"A",
"new",
"slice",
"is",
"allocated",
"to",
"store",
... | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L202-L213 |
14,328 | willf/bitset | bitset.go | InsertAt | 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 elements above the position where we want to insert can simply by shifted
b.set[i] <<= 1
// we take the most significant bit of the previous element and set it as
// the least significant bit of the current element
b.set[i] |= (b.set[i-1] & 0x8000000000000000) >> 63
}
// generate a mask to extract the data that we need to shift left
// within the element where we insert a bit
dataMask := ^(uint64(1)<<uint64(idx&(wordSize-1)) - 1)
// extract that data that we'll shift
data := b.set[i] & dataMask
// set the positions of the data mask to 0 in the element where we insert
b.set[i] &= ^dataMask
// shift data mask to the left and insert its data to the slice element
b.set[i] |= data << 1
// add 1 to length of BitSet
b.length++
return b
} | go | 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 elements above the position where we want to insert can simply by shifted
b.set[i] <<= 1
// we take the most significant bit of the previous element and set it as
// the least significant bit of the current element
b.set[i] |= (b.set[i-1] & 0x8000000000000000) >> 63
}
// generate a mask to extract the data that we need to shift left
// within the element where we insert a bit
dataMask := ^(uint64(1)<<uint64(idx&(wordSize-1)) - 1)
// extract that data that we'll shift
data := b.set[i] & dataMask
// set the positions of the data mask to 0 in the element where we insert
b.set[i] &= ^dataMask
// shift data mask to the left and insert its data to the slice element
b.set[i] |= data << 1
// add 1 to length of BitSet
b.length++
return b
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"InsertAt",
"(",
"idx",
"uint",
")",
"*",
"BitSet",
"{",
"insertAtElement",
":=",
"(",
"idx",
">>",
"log2WordSize",
")",
"\n\n",
"// if length of set is a multiple of wordSize we need to allocate more space first",
"if",
"b",
".... | // InsertAt takes an index which indicates where a bit should be
// inserted. Then it shifts all the bits in the set to the left by 1, starting
// from the given index position, and sets the index position to 0.
//
// Depending on the size of your BitSet, and where you are inserting the new entry,
// this method could be extremely slow and in some cases might cause the entire BitSet
// to be recopied. | [
"InsertAt",
"takes",
"an",
"index",
"which",
"indicates",
"where",
"a",
"bit",
"should",
"be",
"inserted",
".",
"Then",
"it",
"shifts",
"all",
"the",
"bits",
"in",
"the",
"set",
"to",
"the",
"left",
"by",
"1",
"starting",
"from",
"the",
"given",
"index",... | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L222-L257 |
14,329 | willf/bitset | bitset.go | ClearAll | func (b *BitSet) ClearAll() *BitSet {
if b != nil && b.set != nil {
for i := range b.set {
b.set[i] = 0
}
}
return b
} | go | func (b *BitSet) ClearAll() *BitSet {
if b != nil && b.set != nil {
for i := range b.set {
b.set[i] = 0
}
}
return b
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"ClearAll",
"(",
")",
"*",
"BitSet",
"{",
"if",
"b",
"!=",
"nil",
"&&",
"b",
".",
"set",
"!=",
"nil",
"{",
"for",
"i",
":=",
"range",
"b",
".",
"set",
"{",
"b",
".",
"set",
"[",
"i",
"]",
"=",
"0",
"\... | // ClearAll clears the entire BitSet | [
"ClearAll",
"clears",
"the",
"entire",
"BitSet"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L428-L435 |
14,330 | willf/bitset | bitset.go | Clone | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Clone",
"(",
")",
"*",
"BitSet",
"{",
"c",
":=",
"New",
"(",
"b",
".",
"length",
")",
"\n",
"if",
"b",
".",
"set",
"!=",
"nil",
"{",
"// Clone should not modify current object",
"copy",
"(",
"c",
".",
"set",
"... | // Clone this BitSet | [
"Clone",
"this",
"BitSet"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L443-L449 |
14,331 | willf/bitset | bitset.go | Copy | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Copy",
"(",
"c",
"*",
"BitSet",
")",
"(",
"count",
"uint",
")",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"b",
".",
"set",
"!=",
"nil",
"{",
"// Copy should not modify current object",
... | // Copy into a destination BitSet
// Returning the size of the destination BitSet
// like array copy | [
"Copy",
"into",
"a",
"destination",
"BitSet",
"Returning",
"the",
"size",
"of",
"the",
"destination",
"BitSet",
"like",
"array",
"copy"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L454-L466 |
14,332 | willf/bitset | bitset.go | Equal | 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 {
if c.set[p] != v {
return false
}
}
return true
} | go | 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 {
if c.set[p] != v {
return false
}
}
return true
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"Equal",
"(",
"c",
"*",
"BitSet",
")",
"bool",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"b",
".",
"length",
"!=",
"c",
".",
"length",
"{",
"return",
"false",
"\n",
"}",
... | // Equal tests the equvalence of two BitSets.
// False if they are of different sizes, otherwise true
// only if all the same bits are set | [
"Equal",
"tests",
"the",
"equvalence",
"of",
"two",
"BitSets",
".",
"False",
"if",
"they",
"are",
"of",
"different",
"sizes",
"otherwise",
"true",
"only",
"if",
"all",
"the",
"same",
"bits",
"are",
"set"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L479-L497 |
14,333 | willf/bitset | bitset.go | DifferenceCardinality | 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 | 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)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"DifferenceCardinality",
"(",
"compare",
"*",
"BitSet",
")",
"uint",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"panicIfNull",
"(",
"compare",
")",
"\n",
"l",
":=",
"int",
"(",
"compare",
".",
"wordCount",
"(",
")",
... | // DifferenceCardinality computes the cardinality of the differnce | [
"DifferenceCardinality",
"computes",
"the",
"cardinality",
"of",
"the",
"differnce"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L522-L533 |
14,334 | willf/bitset | bitset.go | IntersectionCardinality | 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 | 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)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"IntersectionCardinality",
"(",
"compare",
"*",
"BitSet",
")",
"uint",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"panicIfNull",
"(",
"compare",
")",
"\n",
"b",
",",
"compare",
"=",
"sortByLength",
"(",
"b",
",",
"co... | // IntersectionCardinality computes the cardinality of the union | [
"IntersectionCardinality",
"computes",
"the",
"cardinality",
"of",
"the",
"union"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L574-L580 |
14,335 | willf/bitset | bitset.go | UnionCardinality | 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 | 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)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"UnionCardinality",
"(",
"compare",
"*",
"BitSet",
")",
"uint",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"panicIfNull",
"(",
"compare",
")",
"\n",
"b",
",",
"compare",
"=",
"sortByLength",
"(",
"b",
",",
"compare",... | // UnionCardinality computes the cardinality of the uniton of the base set
// and the compare set. | [
"UnionCardinality",
"computes",
"the",
"cardinality",
"of",
"the",
"uniton",
"of",
"the",
"base",
"set",
"and",
"the",
"compare",
"set",
"."
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L618-L627 |
14,336 | willf/bitset | bitset.go | SymmetricDifferenceCardinality | 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 | 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)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"SymmetricDifferenceCardinality",
"(",
"compare",
"*",
"BitSet",
")",
"uint",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"panicIfNull",
"(",
"compare",
")",
"\n",
"b",
",",
"compare",
"=",
"sortByLength",
"(",
"b",
","... | // SymmetricDifferenceCardinality computes the cardinality of the symmetric difference | [
"SymmetricDifferenceCardinality",
"computes",
"the",
"cardinality",
"of",
"the",
"symmetric",
"difference"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L666-L675 |
14,337 | willf/bitset | bitset.go | cleanLastWord | func (b *BitSet) cleanLastWord() {
if !b.isLenExactMultiple() {
b.set[len(b.set)-1] &= allBits >> (wordSize - b.length%wordSize)
}
} | go | func (b *BitSet) cleanLastWord() {
if !b.isLenExactMultiple() {
b.set[len(b.set)-1] &= allBits >> (wordSize - b.length%wordSize)
}
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"cleanLastWord",
"(",
")",
"{",
"if",
"!",
"b",
".",
"isLenExactMultiple",
"(",
")",
"{",
"b",
".",
"set",
"[",
"len",
"(",
"b",
".",
"set",
")",
"-",
"1",
"]",
"&=",
"allBits",
">>",
"(",
"wordSize",
"-",
... | // Clean last word by setting unused bits to 0 | [
"Clean",
"last",
"word",
"by",
"setting",
"unused",
"bits",
"to",
"0"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L705-L709 |
14,338 | willf/bitset | bitset.go | All | func (b *BitSet) All() bool {
panicIfNull(b)
return b.Count() == b.length
} | go | func (b *BitSet) All() bool {
panicIfNull(b)
return b.Count() == b.length
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"All",
"(",
")",
"bool",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"return",
"b",
".",
"Count",
"(",
")",
"==",
"b",
".",
"length",
"\n",
"}"
] | // All returns true if all bits are set, false otherwise. Returns true for
// empty sets. | [
"All",
"returns",
"true",
"if",
"all",
"bits",
"are",
"set",
"false",
"otherwise",
".",
"Returns",
"true",
"for",
"empty",
"sets",
"."
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L724-L727 |
14,339 | willf/bitset | bitset.go | None | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"None",
"(",
")",
"bool",
"{",
"panicIfNull",
"(",
"b",
")",
"\n",
"if",
"b",
"!=",
"nil",
"&&",
"b",
".",
"set",
"!=",
"nil",
"{",
"for",
"_",
",",
"word",
":=",
"range",
"b",
".",
"set",
"{",
"if",
"w... | // None returns true if no bit is set, false otherwise. Retursn true for
// empty sets. | [
"None",
"returns",
"true",
"if",
"no",
"bit",
"is",
"set",
"false",
"otherwise",
".",
"Retursn",
"true",
"for",
"empty",
"sets",
"."
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L731-L742 |
14,340 | willf/bitset | bitset.go | IsSuperSet | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"IsSuperSet",
"(",
"other",
"*",
"BitSet",
")",
"bool",
"{",
"for",
"i",
",",
"e",
":=",
"other",
".",
"NextSet",
"(",
"0",
")",
";",
"e",
";",
"i",
",",
"e",
"=",
"other",
".",
"NextSet",
"(",
"i",
"+",
... | // IsSuperSet returns true if this is a superset of the other set | [
"IsSuperSet",
"returns",
"true",
"if",
"this",
"is",
"a",
"superset",
"of",
"the",
"other",
"set"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L751-L758 |
14,341 | willf/bitset | bitset.go | IsStrictSuperSet | func (b *BitSet) IsStrictSuperSet(other *BitSet) bool {
return b.Count() > other.Count() && b.IsSuperSet(other)
} | go | func (b *BitSet) IsStrictSuperSet(other *BitSet) bool {
return b.Count() > other.Count() && b.IsSuperSet(other)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"IsStrictSuperSet",
"(",
"other",
"*",
"BitSet",
")",
"bool",
"{",
"return",
"b",
".",
"Count",
"(",
")",
">",
"other",
".",
"Count",
"(",
")",
"&&",
"b",
".",
"IsSuperSet",
"(",
"other",
")",
"\n",
"}"
] | // IsStrictSuperSet returns true if this is a strict superset of the other set | [
"IsStrictSuperSet",
"returns",
"true",
"if",
"this",
"is",
"a",
"strict",
"superset",
"of",
"the",
"other",
"set"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L761-L763 |
14,342 | willf/bitset | bitset.go | DumpAsBits | 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 | 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()
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"DumpAsBits",
"(",
")",
"string",
"{",
"if",
"b",
".",
"set",
"==",
"nil",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"buffer",
":=",
"bytes",
".",
"NewBufferString",
"(",
"\"",
"\"",
")",
"\n",
"i",
":=",
... | // DumpAsBits dumps a bit set as a string of bits | [
"DumpAsBits",
"dumps",
"a",
"bit",
"set",
"as",
"a",
"string",
"of",
"bits"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L766-L776 |
14,343 | willf/bitset | bitset.go | BinaryStorageSize | func (b *BitSet) BinaryStorageSize() int {
return binary.Size(uint64(0)) + binary.Size(b.set)
} | go | func (b *BitSet) BinaryStorageSize() int {
return binary.Size(uint64(0)) + binary.Size(b.set)
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"BinaryStorageSize",
"(",
")",
"int",
"{",
"return",
"binary",
".",
"Size",
"(",
"uint64",
"(",
"0",
")",
")",
"+",
"binary",
".",
"Size",
"(",
"b",
".",
"set",
")",
"\n",
"}"
] | // BinaryStorageSize returns the binary storage requirements | [
"BinaryStorageSize",
"returns",
"the",
"binary",
"storage",
"requirements"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L779-L781 |
14,344 | willf/bitset | bitset.go | WriteTo | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"WriteTo",
"(",
"stream",
"io",
".",
"Writer",
")",
"(",
"int64",
",",
"error",
")",
"{",
"length",
":=",
"uint64",
"(",
"b",
".",
"length",
")",
"\n\n",
"// Write length",
"err",
":=",
"binary",
".",
"Write",
... | // WriteTo writes a BitSet to a stream | [
"WriteTo",
"writes",
"a",
"BitSet",
"to",
"a",
"stream"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L784-L796 |
14,345 | willf/bitset | bitset.go | ReadFrom | 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")
}
// Read remaining bytes as set
err = binary.Read(stream, binaryOrder, newset.set)
if err != nil {
return 0, err
}
*b = *newset
return int64(b.BinaryStorageSize()), nil
} | go | 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")
}
// Read remaining bytes as set
err = binary.Read(stream, binaryOrder, newset.set)
if err != nil {
return 0, err
}
*b = *newset
return int64(b.BinaryStorageSize()), nil
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"ReadFrom",
"(",
"stream",
"io",
".",
"Reader",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"length",
"uint64",
"\n\n",
"// Read length first",
"err",
":=",
"binary",
".",
"Read",
"(",
"stream",
",",
"binaryO... | // ReadFrom reads a BitSet from a stream written using WriteTo | [
"ReadFrom",
"reads",
"a",
"BitSet",
"from",
"a",
"stream",
"written",
"using",
"WriteTo"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L799-L821 |
14,346 | willf/bitset | bitset.go | MarshalBinary | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"MarshalBinary",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"writer",
":=",
"bufio",
".",
"NewWriter",
"(",
"&",
"buf",
")",
"\n\n",
"_",
",",
"err",
... | // MarshalBinary encodes a BitSet into a binary form and returns the result. | [
"MarshalBinary",
"encodes",
"a",
"BitSet",
"into",
"a",
"binary",
"form",
"and",
"returns",
"the",
"result",
"."
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L824-L836 |
14,347 | willf/bitset | bitset.go | UnmarshalBinary | func (b *BitSet) UnmarshalBinary(data []byte) error {
buf := bytes.NewReader(data)
reader := bufio.NewReader(buf)
_, err := b.ReadFrom(reader)
return err
} | go | func (b *BitSet) UnmarshalBinary(data []byte) error {
buf := bytes.NewReader(data)
reader := bufio.NewReader(buf)
_, err := b.ReadFrom(reader)
return err
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"UnmarshalBinary",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"buf",
":=",
"bytes",
".",
"NewReader",
"(",
"data",
")",
"\n",
"reader",
":=",
"bufio",
".",
"NewReader",
"(",
"buf",
")",
"\n\n",
"_",
",",... | // UnmarshalBinary decodes the binary form generated by MarshalBinary. | [
"UnmarshalBinary",
"decodes",
"the",
"binary",
"form",
"generated",
"by",
"MarshalBinary",
"."
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L839-L846 |
14,348 | willf/bitset | bitset.go | MarshalJSON | 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 | 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()))
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"buffer",
":=",
"bytes",
".",
"NewBuffer",
"(",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"b",
".",
"BinaryStorageSize",
"(",
")",
... | // MarshalJSON marshals a BitSet as a JSON structure | [
"MarshalJSON",
"marshals",
"a",
"BitSet",
"as",
"a",
"JSON",
"structure"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L849-L858 |
14,349 | willf/bitset | bitset.go | UnmarshalJSON | 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 | 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
} | [
"func",
"(",
"b",
"*",
"BitSet",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"// Unmarshal as string",
"var",
"s",
"string",
"\n",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"data",
",",
"&",
"s",
")",
"\n",
"if",
"err",
... | // UnmarshalJSON unmarshals a BitSet from JSON created using MarshalJSON | [
"UnmarshalJSON",
"unmarshals",
"a",
"BitSet",
"from",
"JSON",
"created",
"using",
"MarshalJSON"
] | 77892cd8d53fa6524772426bc444dd2e3b4fb18f | https://github.com/willf/bitset/blob/77892cd8d53fa6524772426bc444dd2e3b4fb18f/bitset.go#L861-L877 |
14,350 | valyala/bytebufferpool | pool.go | Get | 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 | 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)),
}
} | [
"func",
"(",
"p",
"*",
"Pool",
")",
"Get",
"(",
")",
"*",
"ByteBuffer",
"{",
"v",
":=",
"p",
".",
"pool",
".",
"Get",
"(",
")",
"\n",
"if",
"v",
"!=",
"nil",
"{",
"return",
"v",
".",
"(",
"*",
"ByteBuffer",
")",
"\n",
"}",
"\n",
"return",
"... | // Get returns new byte buffer with zero length.
//
// The byte buffer may be returned to the pool via Put after the use
// in order to minimize GC overhead. | [
"Get",
"returns",
"new",
"byte",
"buffer",
"with",
"zero",
"length",
".",
"The",
"byte",
"buffer",
"may",
"be",
"returned",
"to",
"the",
"pool",
"via",
"Put",
"after",
"the",
"use",
"in",
"order",
"to",
"minimize",
"GC",
"overhead",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/pool.go#L48-L56 |
14,351 | valyala/bytebufferpool | pool.go | Put | 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 | 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)
}
} | [
"func",
"(",
"p",
"*",
"Pool",
")",
"Put",
"(",
"b",
"*",
"ByteBuffer",
")",
"{",
"idx",
":=",
"index",
"(",
"len",
"(",
"b",
".",
"B",
")",
")",
"\n\n",
"if",
"atomic",
".",
"AddUint64",
"(",
"&",
"p",
".",
"calls",
"[",
"idx",
"]",
",",
"... | // Put releases byte buffer obtained via Get to the pool.
//
// The buffer mustn't be accessed after returning to the pool. | [
"Put",
"releases",
"byte",
"buffer",
"obtained",
"via",
"Get",
"to",
"the",
"pool",
".",
"The",
"buffer",
"mustn",
"t",
"be",
"accessed",
"after",
"returning",
"to",
"the",
"pool",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/pool.go#L67-L79 |
14,352 | valyala/bytebufferpool | bytebuffer.go | ReadFrom | 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, err := r.Read(p[n:])
n += int64(nn)
if err != nil {
b.B = p[:n]
n -= nStart
if err == io.EOF {
return n, nil
}
return n, err
}
}
} | go | 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, err := r.Read(p[n:])
n += int64(nn)
if err != nil {
b.B = p[:n]
n -= nStart
if err == io.EOF {
return n, nil
}
return n, err
}
}
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"ReadFrom",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int64",
",",
"error",
")",
"{",
"p",
":=",
"b",
".",
"B",
"\n",
"nStart",
":=",
"int64",
"(",
"len",
"(",
"p",
")",
")",
"\n",
"nMax",
":=",
"int6... | // ReadFrom implements io.ReaderFrom.
//
// The function appends all the data read from r to b. | [
"ReadFrom",
"implements",
"io",
".",
"ReaderFrom",
".",
"The",
"function",
"appends",
"all",
"the",
"data",
"read",
"from",
"r",
"to",
"b",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L27-L56 |
14,353 | valyala/bytebufferpool | bytebuffer.go | WriteTo | func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write(b.B)
return int64(n), err
} | go | func (b *ByteBuffer) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write(b.B)
return int64(n), err
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"WriteTo",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"int64",
",",
"error",
")",
"{",
"n",
",",
"err",
":=",
"w",
".",
"Write",
"(",
"b",
".",
"B",
")",
"\n",
"return",
"int64",
"(",
"n",
")",
",",
"... | // WriteTo implements io.WriterTo. | [
"WriteTo",
"implements",
"io",
".",
"WriterTo",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L59-L62 |
14,354 | valyala/bytebufferpool | bytebuffer.go | Write | func (b *ByteBuffer) Write(p []byte) (int, error) {
b.B = append(b.B, p...)
return len(p), nil
} | go | func (b *ByteBuffer) Write(p []byte) (int, error) {
b.B = append(b.B, p...)
return len(p), nil
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"b",
".",
"B",
"=",
"append",
"(",
"b",
".",
"B",
",",
"p",
"...",
")",
"\n",
"return",
"len",
"(",
"p",
")",
",",
"ni... | // Write implements io.Writer - it appends p to ByteBuffer.B | [
"Write",
"implements",
"io",
".",
"Writer",
"-",
"it",
"appends",
"p",
"to",
"ByteBuffer",
".",
"B"
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L72-L75 |
14,355 | valyala/bytebufferpool | bytebuffer.go | WriteByte | func (b *ByteBuffer) WriteByte(c byte) error {
b.B = append(b.B, c)
return nil
} | go | func (b *ByteBuffer) WriteByte(c byte) error {
b.B = append(b.B, c)
return nil
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"WriteByte",
"(",
"c",
"byte",
")",
"error",
"{",
"b",
".",
"B",
"=",
"append",
"(",
"b",
".",
"B",
",",
"c",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteByte appends the byte c to the buffer.
//
// The purpose of this function is bytes.Buffer compatibility.
//
// The function always returns nil. | [
"WriteByte",
"appends",
"the",
"byte",
"c",
"to",
"the",
"buffer",
".",
"The",
"purpose",
"of",
"this",
"function",
"is",
"bytes",
".",
"Buffer",
"compatibility",
".",
"The",
"function",
"always",
"returns",
"nil",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L82-L85 |
14,356 | valyala/bytebufferpool | bytebuffer.go | WriteString | func (b *ByteBuffer) WriteString(s string) (int, error) {
b.B = append(b.B, s...)
return len(s), nil
} | go | func (b *ByteBuffer) WriteString(s string) (int, error) {
b.B = append(b.B, s...)
return len(s), nil
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"WriteString",
"(",
"s",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"b",
".",
"B",
"=",
"append",
"(",
"b",
".",
"B",
",",
"s",
"...",
")",
"\n",
"return",
"len",
"(",
"s",
")",
",",
"nil",
... | // WriteString appends s to ByteBuffer.B. | [
"WriteString",
"appends",
"s",
"to",
"ByteBuffer",
".",
"B",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L88-L91 |
14,357 | valyala/bytebufferpool | bytebuffer.go | Set | func (b *ByteBuffer) Set(p []byte) {
b.B = append(b.B[:0], p...)
} | go | func (b *ByteBuffer) Set(p []byte) {
b.B = append(b.B[:0], p...)
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"Set",
"(",
"p",
"[",
"]",
"byte",
")",
"{",
"b",
".",
"B",
"=",
"append",
"(",
"b",
".",
"B",
"[",
":",
"0",
"]",
",",
"p",
"...",
")",
"\n",
"}"
] | // Set sets ByteBuffer.B to p. | [
"Set",
"sets",
"ByteBuffer",
".",
"B",
"to",
"p",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L94-L96 |
14,358 | valyala/bytebufferpool | bytebuffer.go | SetString | func (b *ByteBuffer) SetString(s string) {
b.B = append(b.B[:0], s...)
} | go | func (b *ByteBuffer) SetString(s string) {
b.B = append(b.B[:0], s...)
} | [
"func",
"(",
"b",
"*",
"ByteBuffer",
")",
"SetString",
"(",
"s",
"string",
")",
"{",
"b",
".",
"B",
"=",
"append",
"(",
"b",
".",
"B",
"[",
":",
"0",
"]",
",",
"s",
"...",
")",
"\n",
"}"
] | // SetString sets ByteBuffer.B to s. | [
"SetString",
"sets",
"ByteBuffer",
".",
"B",
"to",
"s",
"."
] | cdfbe9377474227bb42120c1e22fd4433e7f69bf | https://github.com/valyala/bytebufferpool/blob/cdfbe9377474227bb42120c1e22fd4433e7f69bf/bytebuffer.go#L99-L101 |
14,359 | kyokomi/emoji | emoji.go | Print | func Print(a ...interface{}) (int, error) {
return fmt.Print(compile(fmt.Sprint(a...)))
} | go | func Print(a ...interface{}) (int, error) {
return fmt.Print(compile(fmt.Sprint(a...)))
} | [
"func",
"Print",
"(",
"a",
"...",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"fmt",
".",
"Print",
"(",
"compile",
"(",
"fmt",
".",
"Sprint",
"(",
"a",
"...",
")",
")",
")",
"\n",
"}"
] | // Print is fmt.Print which supports emoji | [
"Print",
"is",
"fmt",
".",
"Print",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L91-L93 |
14,360 | kyokomi/emoji | emoji.go | Println | func Println(a ...interface{}) (int, error) {
return fmt.Println(compile(fmt.Sprint(a...)))
} | go | func Println(a ...interface{}) (int, error) {
return fmt.Println(compile(fmt.Sprint(a...)))
} | [
"func",
"Println",
"(",
"a",
"...",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"fmt",
".",
"Println",
"(",
"compile",
"(",
"fmt",
".",
"Sprint",
"(",
"a",
"...",
")",
")",
")",
"\n",
"}"
] | // Println is fmt.Println which supports emoji | [
"Println",
"is",
"fmt",
".",
"Println",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L96-L98 |
14,361 | kyokomi/emoji | emoji.go | Fprint | func Fprint(w io.Writer, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprint(a...)))
} | go | func Fprint(w io.Writer, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprint(a...)))
} | [
"func",
"Fprint",
"(",
"w",
"io",
".",
"Writer",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"compile",
"(",
"fmt",
".",
"Sprint",
"(",
"a",
"...",
")",
")",
... | // Fprint is fmt.Fprint which supports emoji | [
"Fprint",
"is",
"fmt",
".",
"Fprint",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L106-L108 |
14,362 | kyokomi/emoji | emoji.go | Fprintf | func Fprintf(w io.Writer, format string, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprintf(format, a...)))
} | go | func Fprintf(w io.Writer, format string, a ...interface{}) (int, error) {
return fmt.Fprint(w, compile(fmt.Sprintf(format, a...)))
} | [
"func",
"Fprintf",
"(",
"w",
"io",
".",
"Writer",
",",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"fmt",
".",
"Fprint",
"(",
"w",
",",
"compile",
"(",
"fmt",
".",
"Sprintf",
"(",... | // Fprintf is fmt.Fprintf which supports emoji | [
"Fprintf",
"is",
"fmt",
".",
"Fprintf",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L116-L118 |
14,363 | kyokomi/emoji | emoji.go | Sprintf | func Sprintf(format string, a ...interface{}) string {
return compile(fmt.Sprintf(format, a...))
} | go | func Sprintf(format string, a ...interface{}) string {
return compile(fmt.Sprintf(format, a...))
} | [
"func",
"Sprintf",
"(",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"string",
"{",
"return",
"compile",
"(",
"fmt",
".",
"Sprintf",
"(",
"format",
",",
"a",
"...",
")",
")",
"\n",
"}"
] | // Sprintf is fmt.Sprintf which supports emoji | [
"Sprintf",
"is",
"fmt",
".",
"Sprintf",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L126-L128 |
14,364 | kyokomi/emoji | emoji.go | Errorf | func Errorf(format string, a ...interface{}) error {
return errors.New(compile(Sprintf(format, a...)))
} | go | func Errorf(format string, a ...interface{}) error {
return errors.New(compile(Sprintf(format, a...)))
} | [
"func",
"Errorf",
"(",
"format",
"string",
",",
"a",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"return",
"errors",
".",
"New",
"(",
"compile",
"(",
"Sprintf",
"(",
"format",
",",
"a",
"...",
")",
")",
")",
"\n",
"}"
] | // Errorf is fmt.Errorf which supports emoji | [
"Errorf",
"is",
"fmt",
".",
"Errorf",
"which",
"supports",
"emoji"
] | 51762253ec2b5dafce2d33adfb0d49121924ee58 | https://github.com/kyokomi/emoji/blob/51762253ec2b5dafce2d33adfb0d49121924ee58/emoji.go#L131-L133 |
14,365 | opencontainers/runtime-tools | generate/config.go | InitConfigLinuxResourcesCPU | func (g *Generator) InitConfigLinuxResourcesCPU() {
g.initConfigLinuxResources()
if g.Config.Linux.Resources.CPU == nil {
g.Config.Linux.Resources.CPU = &rspec.LinuxCPU{}
}
} | go | func (g *Generator) InitConfigLinuxResourcesCPU() {
g.initConfigLinuxResources()
if g.Config.Linux.Resources.CPU == nil {
g.Config.Linux.Resources.CPU = &rspec.LinuxCPU{}
}
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"InitConfigLinuxResourcesCPU",
"(",
")",
"{",
"g",
".",
"initConfigLinuxResources",
"(",
")",
"\n",
"if",
"g",
".",
"Config",
".",
"Linux",
".",
"Resources",
".",
"CPU",
"==",
"nil",
"{",
"g",
".",
"Config",
"."... | // InitConfigLinuxResourcesCPU initializes CPU of Linux resources | [
"InitConfigLinuxResourcesCPU",
"initializes",
"CPU",
"of",
"Linux",
"resources"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/config.go#L98-L103 |
14,366 | opencontainers/runtime-tools | cgroups/cgroups_v1.go | GetPidsData | 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("In the case of an absolute path, the runtime MUST take the path to be relative to the cgroups mount point"), rspec.Version)
}
return nil, err
}
}
lp := &rspec.LinuxPids{}
fileName := strings.Join([]string{"pids", "max"}, ".")
filePath := filepath.Join(cg.MountPath, "pids", cgPath, fileName)
if !filepath.IsAbs(cgPath) {
subPath, err := GetSubsystemPath(pid, "pids")
if err != nil {
return nil, err
}
if !strings.Contains(subPath, cgPath) {
return nil, fmt.Errorf("cgroup subsystem %s is not mounted as expected", "pids")
}
filePath = filepath.Join(cg.MountPath, "pids", subPath, fileName)
}
contents, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
res, err := strconv.ParseInt(strings.TrimSpace(string(contents)), 10, 64)
if err != nil {
if os.IsNotExist(err) {
return nil, specerror.NewError(specerror.CgroupsPathAttach, fmt.Errorf("The runtime MUST consistently attach to the same place in the cgroups hierarchy given the same value of `cgroupsPath`"), rspec.Version)
}
return nil, err
}
lp.Limit = res
return lp, nil
} | go | 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("In the case of an absolute path, the runtime MUST take the path to be relative to the cgroups mount point"), rspec.Version)
}
return nil, err
}
}
lp := &rspec.LinuxPids{}
fileName := strings.Join([]string{"pids", "max"}, ".")
filePath := filepath.Join(cg.MountPath, "pids", cgPath, fileName)
if !filepath.IsAbs(cgPath) {
subPath, err := GetSubsystemPath(pid, "pids")
if err != nil {
return nil, err
}
if !strings.Contains(subPath, cgPath) {
return nil, fmt.Errorf("cgroup subsystem %s is not mounted as expected", "pids")
}
filePath = filepath.Join(cg.MountPath, "pids", subPath, fileName)
}
contents, err := ioutil.ReadFile(filePath)
if err != nil {
return nil, err
}
res, err := strconv.ParseInt(strings.TrimSpace(string(contents)), 10, 64)
if err != nil {
if os.IsNotExist(err) {
return nil, specerror.NewError(specerror.CgroupsPathAttach, fmt.Errorf("The runtime MUST consistently attach to the same place in the cgroups hierarchy given the same value of `cgroupsPath`"), rspec.Version)
}
return nil, err
}
lp.Limit = res
return lp, nil
} | [
"func",
"(",
"cg",
"*",
"CgroupV1",
")",
"GetPidsData",
"(",
"pid",
"int",
",",
"cgPath",
"string",
")",
"(",
"*",
"rspec",
".",
"LinuxPids",
",",
"error",
")",
"{",
"if",
"filepath",
".",
"IsAbs",
"(",
"cgPath",
")",
"{",
"path",
":=",
"filepath",
... | // GetPidsData gets cgroup pids data | [
"GetPidsData",
"gets",
"cgroup",
"pids",
"data"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/cgroups/cgroups_v1.go#L641-L679 |
14,367 | opencontainers/runtime-tools | generate/seccomp/syscall_compare.go | decideCourseOfAction | 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(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, nothing)
}
if sameAction(newSyscall, &syscall) {
if bothHaveArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
if onlyOneHasArgs(newSyscall, &syscall) {
if firstParamOnlyHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
} else {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, nothing)
}
}
}
if !sameAction(newSyscall, &syscall) {
if bothHaveArgs(newSyscall, &syscall) {
if sameArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
}
if !sameArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
}
if onlyOneHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
if neitherHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
}
}
}
}
if !ruleForSyscallAlreadyExists {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
// Nothing has highest priority
for _, determinedAction := range sliceOfDeterminedActions {
if determinedAction == nothing {
return determinedAction, nil
}
}
// Overwrite has second highest priority
for _, determinedAction := range sliceOfDeterminedActions {
if strings.Contains(determinedAction, seccompOverwrite) {
return determinedAction, nil
}
}
// Append has the lowest priority
for _, determinedAction := range sliceOfDeterminedActions {
if determinedAction == seccompAppend {
return determinedAction, nil
}
}
return "", fmt.Errorf("Trouble determining action: %s", sliceOfDeterminedActions)
} | go | 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(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, nothing)
}
if sameAction(newSyscall, &syscall) {
if bothHaveArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
if onlyOneHasArgs(newSyscall, &syscall) {
if firstParamOnlyHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
} else {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, nothing)
}
}
}
if !sameAction(newSyscall, &syscall) {
if bothHaveArgs(newSyscall, &syscall) {
if sameArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
}
if !sameArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
}
if onlyOneHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
if neitherHasArgs(newSyscall, &syscall) {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, "overwrite:"+strconv.Itoa(i))
}
}
}
}
if !ruleForSyscallAlreadyExists {
sliceOfDeterminedActions = append(sliceOfDeterminedActions, seccompAppend)
}
// Nothing has highest priority
for _, determinedAction := range sliceOfDeterminedActions {
if determinedAction == nothing {
return determinedAction, nil
}
}
// Overwrite has second highest priority
for _, determinedAction := range sliceOfDeterminedActions {
if strings.Contains(determinedAction, seccompOverwrite) {
return determinedAction, nil
}
}
// Append has the lowest priority
for _, determinedAction := range sliceOfDeterminedActions {
if determinedAction == seccompAppend {
return determinedAction, nil
}
}
return "", fmt.Errorf("Trouble determining action: %s", sliceOfDeterminedActions)
} | [
"func",
"decideCourseOfAction",
"(",
"newSyscall",
"*",
"rspec",
".",
"LinuxSyscall",
",",
"syscalls",
"[",
"]",
"rspec",
".",
"LinuxSyscall",
")",
"(",
"string",
",",
"error",
")",
"{",
"ruleForSyscallAlreadyExists",
":=",
"false",
"\n\n",
"var",
"sliceOfDeterm... | // Determine if a new syscall rule should be appended, overwrite an existing rule
// or if no action should be taken at all | [
"Determine",
"if",
"a",
"new",
"syscall",
"rule",
"should",
"be",
"appended",
"overwrite",
"an",
"existing",
"rule",
"or",
"if",
"no",
"action",
"should",
"be",
"taken",
"at",
"all"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/syscall_compare.go#L14-L84 |
14,368 | opencontainers/runtime-tools | cgroups/cgroups_v2.go | GetPidsData | func GetPidsData(pid int, cgPath string) (*rspec.LinuxPids, error) {
return nil, fmt.Errorf("unimplemented yet")
} | go | func GetPidsData(pid int, cgPath string) (*rspec.LinuxPids, error) {
return nil, fmt.Errorf("unimplemented yet")
} | [
"func",
"GetPidsData",
"(",
"pid",
"int",
",",
"cgPath",
"string",
")",
"(",
"*",
"rspec",
".",
"LinuxPids",
",",
"error",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // GetPidsData gets cgroup pid ints data | [
"GetPidsData",
"gets",
"cgroup",
"pid",
"ints",
"data"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/cgroups/cgroups_v2.go#L45-L47 |
14,369 | opencontainers/runtime-tools | validate/validate_linux.go | LastCap | 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 | 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
} | [
"func",
"LastCap",
"(",
")",
"capability",
".",
"Cap",
"{",
"last",
":=",
"capability",
".",
"CAP_LAST_CAP",
"\n",
"// hack for RHEL6 which has no /proc/sys/kernel/cap_last_cap",
"if",
"last",
"==",
"capability",
".",
"Cap",
"(",
"63",
")",
"{",
"last",
"=",
"ca... | // LastCap return last cap of system | [
"LastCap",
"return",
"last",
"cap",
"of",
"system"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/validate/validate_linux.go#L24-L32 |
14,370 | opencontainers/runtime-tools | generate/seccomp/parse_remove.go | RemoveAllSeccompRules | 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 | 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
} | [
"func",
"RemoveAllSeccompRules",
"(",
"config",
"*",
"rspec",
".",
"LinuxSeccomp",
")",
"error",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"newSyscallSlice",
":=",
"[",
"]",
"rspec",
"... | // RemoveAllSeccompRules removes all seccomp syscall rules | [
"RemoveAllSeccompRules",
"removes",
"all",
"seccomp",
"syscall",
"rules"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/parse_remove.go#L30-L37 |
14,371 | opencontainers/runtime-tools | generate/seccomp/parse_remove.go | RemoveAllMatchingRules | 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.Join(syscall.Names, ","), config)
}
}
return nil
} | go | 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.Join(syscall.Names, ","), config)
}
}
return nil
} | [
"func",
"RemoveAllMatchingRules",
"(",
"config",
"*",
"rspec",
".",
"LinuxSeccomp",
",",
"seccompAction",
"rspec",
".",
"LinuxSeccompAction",
")",
"error",
"{",
"if",
"config",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"... | // RemoveAllMatchingRules will remove any syscall rules that match the specified action | [
"RemoveAllMatchingRules",
"will",
"remove",
"any",
"syscall",
"rules",
"that",
"match",
"the",
"specified",
"action"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/seccomp/parse_remove.go#L40-L52 |
14,372 | opencontainers/runtime-tools | cgroups/cgroups.go | FindCgroup | 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 spaces as \040.
index := strings.Index(text, " - ")
postSeparatorFields := strings.Split(text[index+3:], " ")
numPostFields := len(postSeparatorFields)
// This is an error as we can't detect if the mount is for "cgroup"
if numPostFields == 0 {
return nil, fmt.Errorf("Found no fields post '-' in %q", text)
}
if postSeparatorFields[0] == "cgroup" {
// No need to parse the rest of the postSeparatorFields
cg := &CgroupV1{
MountPath: filepath.Dir(fields[4]),
}
return cg, nil
} else if postSeparatorFields[0] == "cgroup2" {
cgroupv2 = true
continue
//TODO cgroupv2 unimplemented
}
}
if err := scanner.Err(); err != nil {
return nil, err
}
if cgroupv2 {
return nil, fmt.Errorf("cgroupv2 is not supported yet")
}
return nil, fmt.Errorf("cgroup is not found")
} | go | 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 spaces as \040.
index := strings.Index(text, " - ")
postSeparatorFields := strings.Split(text[index+3:], " ")
numPostFields := len(postSeparatorFields)
// This is an error as we can't detect if the mount is for "cgroup"
if numPostFields == 0 {
return nil, fmt.Errorf("Found no fields post '-' in %q", text)
}
if postSeparatorFields[0] == "cgroup" {
// No need to parse the rest of the postSeparatorFields
cg := &CgroupV1{
MountPath: filepath.Dir(fields[4]),
}
return cg, nil
} else if postSeparatorFields[0] == "cgroup2" {
cgroupv2 = true
continue
//TODO cgroupv2 unimplemented
}
}
if err := scanner.Err(); err != nil {
return nil, err
}
if cgroupv2 {
return nil, fmt.Errorf("cgroupv2 is not supported yet")
}
return nil, fmt.Errorf("cgroup is not found")
} | [
"func",
"FindCgroup",
"(",
")",
"(",
"Cgroup",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Clos... | // FindCgroup gets cgroup root mountpoint | [
"FindCgroup",
"gets",
"cgroup",
"root",
"mountpoint"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/cgroups/cgroups.go#L33-L77 |
14,373 | opencontainers/runtime-tools | cgroups/cgroups.go | GetSubsystemPath | 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(elem) < 3 {
continue
}
subelems := strings.Split(elem[1], ",")
for _, subelem := range subelems {
if subelem == subsystem {
return elem[2], nil
}
}
}
return "", fmt.Errorf("subsystem %s not found", subsystem)
} | go | 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(elem) < 3 {
continue
}
subelems := strings.Split(elem[1], ",")
for _, subelem := range subelems {
if subelem == subsystem {
return elem[2], nil
}
}
}
return "", fmt.Errorf("subsystem %s not found", subsystem)
} | [
"func",
"GetSubsystemPath",
"(",
"pid",
"int",
",",
"subsystem",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"contents",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"pid",
")",
")",
"\n",
... | // GetSubsystemPath gets path of subsystem | [
"GetSubsystemPath",
"gets",
"path",
"of",
"subsystem"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/cgroups/cgroups.go#L80-L101 |
14,374 | opencontainers/runtime-tools | generate/generate.go | NewFromFile | 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 | 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)
} | [
"func",
"NewFromFile",
"(",
"path",
"string",
")",
"(",
"Generator",
",",
"error",
")",
"{",
"cf",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"os",
".",
"IsNotExist",
"(",
"err",
")",
"{",
... | // NewFromFile loads the template specified in a file into a
// configuration Generator. | [
"NewFromFile",
"loads",
"the",
"template",
"specified",
"in",
"a",
"file",
"into",
"a",
"configuration",
"Generator",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L270-L281 |
14,375 | opencontainers/runtime-tools | generate/generate.go | NewFromTemplate | 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,
envMap: envCache,
}, nil
} | go | 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,
envMap: envCache,
}, nil
} | [
"func",
"NewFromTemplate",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"Generator",
",",
"error",
")",
"{",
"var",
"config",
"rspec",
".",
"Spec",
"\n",
"if",
"err",
":=",
"json",
".",
"NewDecoder",
"(",
"r",
")",
".",
"Decode",
"(",
"&",
"config",
")... | // NewFromTemplate loads the template from io.Reader into a
// configuration Generator. | [
"NewFromTemplate",
"loads",
"the",
"template",
"from",
"io",
".",
"Reader",
"into",
"a",
"configuration",
"Generator",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L285-L300 |
14,376 | opencontainers/runtime-tools | generate/generate.go | createEnvCacheMap | 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 | func createEnvCacheMap(env []string) map[string]int {
envMap := make(map[string]int, len(env))
for i, val := range env {
envMap[val] = i
}
return envMap
} | [
"func",
"createEnvCacheMap",
"(",
"env",
"[",
"]",
"string",
")",
"map",
"[",
"string",
"]",
"int",
"{",
"envMap",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"int",
",",
"len",
"(",
"env",
")",
")",
"\n",
"for",
"i",
",",
"val",
":=",
"range",... | // createEnvCacheMap creates a hash map with the ENV variables given by the config | [
"createEnvCacheMap",
"creates",
"a",
"hash",
"map",
"with",
"the",
"ENV",
"variables",
"given",
"by",
"the",
"config"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L303-L309 |
14,377 | opencontainers/runtime-tools | generate/generate.go | Save | 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(g.Config.Linux.Seccomp, "", "\t")
} else {
data, err = json.MarshalIndent(g.Config, "", "\t")
}
if err != nil {
return err
}
_, err = w.Write(data)
if err != nil {
return err
}
return nil
} | go | 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(g.Config.Linux.Seccomp, "", "\t")
} else {
data, err = json.MarshalIndent(g.Config, "", "\t")
}
if err != nil {
return err
}
_, err = w.Write(data)
if err != nil {
return err
}
return nil
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Save",
"(",
"w",
"io",
".",
"Writer",
",",
"exportOpts",
"ExportOptions",
")",
"(",
"err",
"error",
")",
"{",
"var",
"data",
"[",
"]",
"byte",
"\n\n",
"if",
"g",
".",
"Config",
".",
"Linux",
"!=",
"nil",
... | // Save writes the configuration into w. | [
"Save",
"writes",
"the",
"configuration",
"into",
"w",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L328-L356 |
14,378 | opencontainers/runtime-tools | generate/generate.go | SaveToFile | 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 | 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)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SaveToFile",
"(",
"path",
"string",
",",
"exportOpts",
"ExportOptions",
")",
"error",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
... | // SaveToFile writes the configuration into a file. | [
"SaveToFile",
"writes",
"the",
"configuration",
"into",
"a",
"file",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L359-L366 |
14,379 | opencontainers/runtime-tools | generate/generate.go | SetVersion | func (g *Generator) SetVersion(version string) {
g.initConfig()
g.Config.Version = version
} | go | func (g *Generator) SetVersion(version string) {
g.initConfig()
g.Config.Version = version
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetVersion",
"(",
"version",
"string",
")",
"{",
"g",
".",
"initConfig",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Version",
"=",
"version",
"\n",
"}"
] | // SetVersion sets g.Config.Version. | [
"SetVersion",
"sets",
"g",
".",
"Config",
".",
"Version",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L369-L372 |
14,380 | opencontainers/runtime-tools | generate/generate.go | SetRootPath | func (g *Generator) SetRootPath(path string) {
g.initConfigRoot()
g.Config.Root.Path = path
} | go | func (g *Generator) SetRootPath(path string) {
g.initConfigRoot()
g.Config.Root.Path = path
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetRootPath",
"(",
"path",
"string",
")",
"{",
"g",
".",
"initConfigRoot",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Root",
".",
"Path",
"=",
"path",
"\n",
"}"
] | // SetRootPath sets g.Config.Root.Path. | [
"SetRootPath",
"sets",
"g",
".",
"Config",
".",
"Root",
".",
"Path",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L375-L378 |
14,381 | opencontainers/runtime-tools | generate/generate.go | SetRootReadonly | func (g *Generator) SetRootReadonly(b bool) {
g.initConfigRoot()
g.Config.Root.Readonly = b
} | go | func (g *Generator) SetRootReadonly(b bool) {
g.initConfigRoot()
g.Config.Root.Readonly = b
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetRootReadonly",
"(",
"b",
"bool",
")",
"{",
"g",
".",
"initConfigRoot",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Root",
".",
"Readonly",
"=",
"b",
"\n",
"}"
] | // SetRootReadonly sets g.Config.Root.Readonly. | [
"SetRootReadonly",
"sets",
"g",
".",
"Config",
".",
"Root",
".",
"Readonly",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L381-L384 |
14,382 | opencontainers/runtime-tools | generate/generate.go | SetHostname | func (g *Generator) SetHostname(s string) {
g.initConfig()
g.Config.Hostname = s
} | go | func (g *Generator) SetHostname(s string) {
g.initConfig()
g.Config.Hostname = s
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetHostname",
"(",
"s",
"string",
")",
"{",
"g",
".",
"initConfig",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Hostname",
"=",
"s",
"\n",
"}"
] | // SetHostname sets g.Config.Hostname. | [
"SetHostname",
"sets",
"g",
".",
"Config",
".",
"Hostname",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L387-L390 |
14,383 | opencontainers/runtime-tools | generate/generate.go | SetOCIVersion | func (g *Generator) SetOCIVersion(s string) {
g.initConfig()
g.Config.Version = s
} | go | func (g *Generator) SetOCIVersion(s string) {
g.initConfig()
g.Config.Version = s
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetOCIVersion",
"(",
"s",
"string",
")",
"{",
"g",
".",
"initConfig",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Version",
"=",
"s",
"\n",
"}"
] | // SetOCIVersion sets g.Config.Version. | [
"SetOCIVersion",
"sets",
"g",
".",
"Config",
".",
"Version",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L393-L396 |
14,384 | opencontainers/runtime-tools | generate/generate.go | ClearAnnotations | func (g *Generator) ClearAnnotations() {
if g.Config == nil {
return
}
g.Config.Annotations = make(map[string]string)
} | go | func (g *Generator) ClearAnnotations() {
if g.Config == nil {
return
}
g.Config.Annotations = make(map[string]string)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"ClearAnnotations",
"(",
")",
"{",
"if",
"g",
".",
"Config",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"g",
".",
"Config",
".",
"Annotations",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"string",
")",
... | // ClearAnnotations clears g.Config.Annotations. | [
"ClearAnnotations",
"clears",
"g",
".",
"Config",
".",
"Annotations",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L399-L404 |
14,385 | opencontainers/runtime-tools | generate/generate.go | AddAnnotation | func (g *Generator) AddAnnotation(key, value string) {
g.initConfigAnnotations()
g.Config.Annotations[key] = value
} | go | func (g *Generator) AddAnnotation(key, value string) {
g.initConfigAnnotations()
g.Config.Annotations[key] = value
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"AddAnnotation",
"(",
"key",
",",
"value",
"string",
")",
"{",
"g",
".",
"initConfigAnnotations",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Annotations",
"[",
"key",
"]",
"=",
"value",
"\n",
"}"
] | // AddAnnotation adds an annotation into g.Config.Annotations. | [
"AddAnnotation",
"adds",
"an",
"annotation",
"into",
"g",
".",
"Config",
".",
"Annotations",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L407-L410 |
14,386 | opencontainers/runtime-tools | generate/generate.go | RemoveAnnotation | func (g *Generator) RemoveAnnotation(key string) {
if g.Config == nil || g.Config.Annotations == nil {
return
}
delete(g.Config.Annotations, key)
} | go | func (g *Generator) RemoveAnnotation(key string) {
if g.Config == nil || g.Config.Annotations == nil {
return
}
delete(g.Config.Annotations, key)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"RemoveAnnotation",
"(",
"key",
"string",
")",
"{",
"if",
"g",
".",
"Config",
"==",
"nil",
"||",
"g",
".",
"Config",
".",
"Annotations",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"delete",
"(",
"g",
".",
... | // RemoveAnnotation remove an annotation from g.Config.Annotations. | [
"RemoveAnnotation",
"remove",
"an",
"annotation",
"from",
"g",
".",
"Config",
".",
"Annotations",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L413-L418 |
14,387 | opencontainers/runtime-tools | generate/generate.go | SetProcessConsoleSize | func (g *Generator) SetProcessConsoleSize(width, height uint) {
g.initConfigProcessConsoleSize()
g.Config.Process.ConsoleSize.Width = width
g.Config.Process.ConsoleSize.Height = height
} | go | func (g *Generator) SetProcessConsoleSize(width, height uint) {
g.initConfigProcessConsoleSize()
g.Config.Process.ConsoleSize.Width = width
g.Config.Process.ConsoleSize.Height = height
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessConsoleSize",
"(",
"width",
",",
"height",
"uint",
")",
"{",
"g",
".",
"initConfigProcessConsoleSize",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"ConsoleSize",
".",
"Width",
"=",
"width",
... | // SetProcessConsoleSize sets g.Config.Process.ConsoleSize. | [
"SetProcessConsoleSize",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"ConsoleSize",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L429-L433 |
14,388 | opencontainers/runtime-tools | generate/generate.go | SetProcessUID | func (g *Generator) SetProcessUID(uid uint32) {
g.initConfigProcess()
g.Config.Process.User.UID = uid
} | go | func (g *Generator) SetProcessUID(uid uint32) {
g.initConfigProcess()
g.Config.Process.User.UID = uid
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessUID",
"(",
"uid",
"uint32",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"UID",
"=",
"uid",
"\n",
"}"
] | // SetProcessUID sets g.Config.Process.User.UID. | [
"SetProcessUID",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"UID",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L436-L439 |
14,389 | opencontainers/runtime-tools | generate/generate.go | SetProcessUsername | func (g *Generator) SetProcessUsername(username string) {
g.initConfigProcess()
g.Config.Process.User.Username = username
} | go | func (g *Generator) SetProcessUsername(username string) {
g.initConfigProcess()
g.Config.Process.User.Username = username
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessUsername",
"(",
"username",
"string",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"Username",
"=",
"username",
"\n",
"}"
] | // SetProcessUsername sets g.Config.Process.User.Username. | [
"SetProcessUsername",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"Username",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L442-L445 |
14,390 | opencontainers/runtime-tools | generate/generate.go | SetProcessGID | func (g *Generator) SetProcessGID(gid uint32) {
g.initConfigProcess()
g.Config.Process.User.GID = gid
} | go | func (g *Generator) SetProcessGID(gid uint32) {
g.initConfigProcess()
g.Config.Process.User.GID = gid
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessGID",
"(",
"gid",
"uint32",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"GID",
"=",
"gid",
"\n",
"}"
] | // SetProcessGID sets g.Config.Process.User.GID. | [
"SetProcessGID",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"User",
".",
"GID",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L448-L451 |
14,391 | opencontainers/runtime-tools | generate/generate.go | SetProcessCwd | func (g *Generator) SetProcessCwd(cwd string) {
g.initConfigProcess()
g.Config.Process.Cwd = cwd
} | go | func (g *Generator) SetProcessCwd(cwd string) {
g.initConfigProcess()
g.Config.Process.Cwd = cwd
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessCwd",
"(",
"cwd",
"string",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"Cwd",
"=",
"cwd",
"\n",
"}"
] | // SetProcessCwd sets g.Config.Process.Cwd. | [
"SetProcessCwd",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"Cwd",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L454-L457 |
14,392 | opencontainers/runtime-tools | generate/generate.go | SetProcessNoNewPrivileges | func (g *Generator) SetProcessNoNewPrivileges(b bool) {
g.initConfigProcess()
g.Config.Process.NoNewPrivileges = b
} | go | func (g *Generator) SetProcessNoNewPrivileges(b bool) {
g.initConfigProcess()
g.Config.Process.NoNewPrivileges = b
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessNoNewPrivileges",
"(",
"b",
"bool",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"NoNewPrivileges",
"=",
"b",
"\n",
"}"
] | // SetProcessNoNewPrivileges sets g.Config.Process.NoNewPrivileges. | [
"SetProcessNoNewPrivileges",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"NoNewPrivileges",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L460-L463 |
14,393 | opencontainers/runtime-tools | generate/generate.go | SetProcessTerminal | func (g *Generator) SetProcessTerminal(b bool) {
g.initConfigProcess()
g.Config.Process.Terminal = b
} | go | func (g *Generator) SetProcessTerminal(b bool) {
g.initConfigProcess()
g.Config.Process.Terminal = b
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessTerminal",
"(",
"b",
"bool",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"Terminal",
"=",
"b",
"\n",
"}"
] | // SetProcessTerminal sets g.Config.Process.Terminal. | [
"SetProcessTerminal",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"Terminal",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L466-L469 |
14,394 | opencontainers/runtime-tools | generate/generate.go | SetProcessApparmorProfile | func (g *Generator) SetProcessApparmorProfile(prof string) {
g.initConfigProcess()
g.Config.Process.ApparmorProfile = prof
} | go | func (g *Generator) SetProcessApparmorProfile(prof string) {
g.initConfigProcess()
g.Config.Process.ApparmorProfile = prof
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessApparmorProfile",
"(",
"prof",
"string",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"ApparmorProfile",
"=",
"prof",
"\n",
"}"
] | // SetProcessApparmorProfile sets g.Config.Process.ApparmorProfile. | [
"SetProcessApparmorProfile",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"ApparmorProfile",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L472-L475 |
14,395 | opencontainers/runtime-tools | generate/generate.go | SetProcessArgs | func (g *Generator) SetProcessArgs(args []string) {
g.initConfigProcess()
g.Config.Process.Args = args
} | go | func (g *Generator) SetProcessArgs(args []string) {
g.initConfigProcess()
g.Config.Process.Args = args
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetProcessArgs",
"(",
"args",
"[",
"]",
"string",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"Args",
"=",
"args",
"\n",
"}"
] | // SetProcessArgs sets g.Config.Process.Args. | [
"SetProcessArgs",
"sets",
"g",
".",
"Config",
".",
"Process",
".",
"Args",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L478-L481 |
14,396 | opencontainers/runtime-tools | generate/generate.go | ClearProcessEnv | 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 | 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{}
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"ClearProcessEnv",
"(",
")",
"{",
"if",
"g",
".",
"Config",
"==",
"nil",
"||",
"g",
".",
"Config",
".",
"Process",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"g",
".",
"Config",
".",
"Process",
".",
"Env... | // ClearProcessEnv clears g.Config.Process.Env. | [
"ClearProcessEnv",
"clears",
"g",
".",
"Config",
".",
"Process",
".",
"Env",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L484-L491 |
14,397 | opencontainers/runtime-tools | generate/generate.go | AddProcessEnv | func (g *Generator) AddProcessEnv(name, value string) {
if name == "" {
return
}
g.initConfigProcess()
g.addEnv(fmt.Sprintf("%s=%s", name, value), name)
} | go | func (g *Generator) AddProcessEnv(name, value string) {
if name == "" {
return
}
g.initConfigProcess()
g.addEnv(fmt.Sprintf("%s=%s", name, value), name)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"AddProcessEnv",
"(",
"name",
",",
"value",
"string",
")",
"{",
"if",
"name",
"==",
"\"",
"\"",
"{",
"return",
"\n",
"}",
"\n\n",
"g",
".",
"initConfigProcess",
"(",
")",
"\n",
"g",
".",
"addEnv",
"(",
"fmt"... | // AddProcessEnv adds name=value into g.Config.Process.Env, or replaces an
// existing entry with the given name. | [
"AddProcessEnv",
"adds",
"name",
"=",
"value",
"into",
"g",
".",
"Config",
".",
"Process",
".",
"Env",
"or",
"replaces",
"an",
"existing",
"entry",
"with",
"the",
"given",
"name",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L495-L502 |
14,398 | opencontainers/runtime-tools | generate/generate.go | AddMultipleProcessEnv | func (g *Generator) AddMultipleProcessEnv(envs []string) {
g.initConfigProcess()
for _, val := range envs {
split := strings.SplitN(val, "=", 2)
g.addEnv(val, split[0])
}
} | go | func (g *Generator) AddMultipleProcessEnv(envs []string) {
g.initConfigProcess()
for _, val := range envs {
split := strings.SplitN(val, "=", 2)
g.addEnv(val, split[0])
}
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"AddMultipleProcessEnv",
"(",
"envs",
"[",
"]",
"string",
")",
"{",
"g",
".",
"initConfigProcess",
"(",
")",
"\n\n",
"for",
"_",
",",
"val",
":=",
"range",
"envs",
"{",
"split",
":=",
"strings",
".",
"SplitN",
... | // AddMultipleProcessEnv adds multiple name=value into g.Config.Process.Env, or replaces
// existing entries with the given name. | [
"AddMultipleProcessEnv",
"adds",
"multiple",
"name",
"=",
"value",
"into",
"g",
".",
"Config",
".",
"Process",
".",
"Env",
"or",
"replaces",
"existing",
"entries",
"with",
"the",
"given",
"name",
"."
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L506-L513 |
14,399 | opencontainers/runtime-tools | generate/generate.go | addEnv | 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.Process.Env, env)
g.envMap[key] = len(g.Config.Process.Env) - 1
}
} | go | 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.Process.Env, env)
g.envMap[key] = len(g.Config.Process.Env) - 1
}
} | [
"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",
"... | // addEnv looks through adds ENV to the Process and checks envMap for
// any duplicates
// This is called by both AddMultipleProcessEnv and AddProcessEnv | [
"addEnv",
"looks",
"through",
"adds",
"ENV",
"to",
"the",
"Process",
"and",
"checks",
"envMap",
"for",
"any",
"duplicates",
"This",
"is",
"called",
"by",
"both",
"AddMultipleProcessEnv",
"and",
"AddProcessEnv"
] | 095789df6c2bc53a9dd4464cda8c22616d66e0d6 | https://github.com/opencontainers/runtime-tools/blob/095789df6c2bc53a9dd4464cda8c22616d66e0d6/generate/generate.go#L518-L527 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.