_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q173600 | NewHandler | validation | func NewHandler(factory ControllerFactoryFunc, methodName string) ControllerHandler {
handler := ControllerHandler{factory: factory, methodName: methodName}
if !handler.isValid() {
panic("Invalid handler: " + methodName)
}
return handler
} | go | {
"resource": ""
} |
q173601 | Handler | validation | func Handler(gf GoannaHandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
gr := &Request{Request: r}
gf(gr).Send(w)
}
} | go | {
"resource": ""
} |
q173602 | SetRequest | validation | func (c *Controller) SetRequest(req *http.Request) {
c.Request = &Request{Request: req}
} | go | {
"resource": ""
} |
q173603 | Session | validation | func (c *Controller) Session() Session {
if c.Request.session == nil {
c.Request.session = c.sessionFinder(c.Request)
}
return c.Request.session
} | go | {
"resource": ""
} |
q173604 | RenderView | validation | func (c *Controller) RenderView(templateStr string, vars interface{}) []byte {
t, err := template.New("RenderView").Parse(templateStr)
if err != nil {
panic(err.Error())
}
return c.RenderTemplate(t, vars)
} | go | {
"resource": ""
} |
q173605 | RenderTemplate | validation | func RenderTemplate(t *template.Template, vars interface{}) []byte {
out := bytes.NewBuffer(nil)
err := t.Execute(out, vars)
if err != nil {
panic(err.Error())
}
return out.Bytes()
} | go | {
"resource": ""
} |
q173606 | RedirectRoute | validation | func (c *Controller) RedirectRoute(routeName string, args ...string) *RedirectResponse {
return NewRedirectResponse(c.UrlFor(routeName, args...).String())
} | go | {
"resource": ""
} |
q173607 | UrlFor | validation | func (c *Controller) UrlFor(routeName string, args ...string) *url.URL {
return UrlFor(routeName, args...)
} | go | {
"resource": ""
} |
q173608 | CookieValue | validation | func (r *Request) CookieValue(name string) string {
c, err := r.Cookie(name)
if err != nil {
return ""
}
return c.Value
} | go | {
"resource": ""
} |
q173609 | BodyData | validation | func (r *Request) BodyData() []byte {
var err error
if !r.bodyRead {
if r.Body != nil {
r.bodyData, err = ioutil.ReadAll(r.Body)
if err != nil {
// catch i/o timeout errors
neterr, isNetError := err.(net.Error)
if isNetError && neterr.Timeout() {
panic(ghttp.NewHttpError(err, http.StatusReque... | go | {
"resource": ""
} |
q173610 | QueryValue | validation | func (r *Request) QueryValue(key string) string {
return r.URL.Query().Get(key)
} | go | {
"resource": ""
} |
q173611 | FormValueOrDefault | validation | func (r *Request) FormValueOrDefault(key string, def string) string {
val := r.FormValue(key)
if val == "" {
val = def
}
return val
} | go | {
"resource": ""
} |
q173612 | UrlValue | validation | func (r *Request) UrlValue(key string) string {
return mux.Vars(r.Request)[key]
} | go | {
"resource": ""
} |
q173613 | Contains | validation | func Contains(s string, substrs []string) bool {
for _, substr := range substrs {
if strings.Contains(s, substr) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q173614 | RemoveStringsFromString | validation | func RemoveStringsFromString(s string, substrs []string) string {
for loop := true; loop; {
loop = false
for _, substr := range substrs {
lastS := s
s = strings.Join(strings.Split(s, substr), "")
if lastS != s {
loop = true
break
}
}
}
return s
} | go | {
"resource": ""
} |
q173615 | Map | validation | func Map(ss []string, callback func(string) string) []string {
newStrings := make([]string, len(ss))
for i, s := range ss {
newStrings[i] = callback(s)
}
return newStrings
} | go | {
"resource": ""
} |
q173616 | Equal | validation | func Equal(a, b []string) bool {
if len(a) != len(b) {
return false
}
for i, v := range a {
if v != b[i] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q173617 | Uniq | validation | func Uniq(items []string) (uniqItems []string) {
sort.Strings(items)
lastitem := ""
for _, item := range items {
if item != lastitem {
uniqItems = append(uniqItems, item)
lastitem = item
}
}
return
} | go | {
"resource": ""
} |
q173618 | NewCookieSigner | validation | func NewCookieSigner(key []byte) CookieSigner {
return CookieSigner{signer: hmac.New(sha256.New, key)}
} | go | {
"resource": ""
} |
q173619 | EncodeCookie | validation | func (c CookieSigner) EncodeCookie(cookie *http.Cookie) {
cookie.Value = c.EncodeValue(cookie.Value)
} | go | {
"resource": ""
} |
q173620 | DecodeCookie | validation | func (c CookieSigner) DecodeCookie(cookie *http.Cookie) error {
data, err := c.DecodeValue(cookie.Value)
if err != nil {
return err
}
cookie.Value = data
return nil
} | go | {
"resource": ""
} |
q173621 | DecodeValue | validation | func (c CookieSigner) DecodeValue(encodedvalue string) (string, error) {
parts := strings.SplitN(encodedvalue, ".", 2)
if len(parts) != 2 {
return "", errors.New("Wrong number of parts")
}
mac, err := base64.URLEncoding.DecodeString(parts[0])
value := parts[1]
if err != nil {
return "", err
}
if !hmac.Equa... | go | {
"resource": ""
} |
q173622 | EncodeValue | validation | func (c CookieSigner) EncodeValue(value string) string {
return fmt.Sprintf("%s.%s",
base64.URLEncoding.EncodeToString(c.mac(value)),
value)
} | go | {
"resource": ""
} |
q173623 | ServeHTTP | validation | func (sh *StatsdLogHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
requestStartTime := time.Now()
sh.handler.ServeHTTP(w, req)
requestDuration := time.Now().Sub(requestStartTime)
description := sh.RequestFormatter(req)
if description != "" {
sh.statter.Counter(1.0, sh.prefix+"."+description+".req... | go | {
"resource": ""
} |
q173624 | NewSprocketsServer | validation | func NewSprocketsServer(target *url.URL) (*SprocketsServer, error) {
s := SprocketsServer{
Handler: httputil.NewSingleHostReverseProxy(target),
target: target,
}
return &s, nil
} | go | {
"resource": ""
} |
q173625 | normaliseKey | validation | func normaliseKey(key string) string {
newkey := url.QueryEscape(key)
if len(newkey) > 250 {
newkey = newkey[:250]
}
return newkey
} | go | {
"resource": ""
} |
q173626 | StopAndLog | validation | func (m *Monitor) StopAndLog(sectionName string) error {
err := m.Stop(sectionName)
if err == nil {
m.Log(sectionName)
}
return err
} | go | {
"resource": ""
} |
q173627 | MonitorFunc | validation | func (m *Monitor) MonitorFunc(section string, myfunc interface{}) []reflect.Value {
return m.MonitorReflectedFunc(section, reflect.ValueOf(myfunc), []reflect.Value{})
} | go | {
"resource": ""
} |
q173628 | MonitorReflectedFunc | validation | func (m *Monitor) MonitorReflectedFunc(section string, reflectedFunc reflect.Value, args []reflect.Value) []reflect.Value {
m.Start(section)
defer m.StopAndLog(section)
return reflectedFunc.Call(args)
} | go | {
"resource": ""
} |
q173629 | LogRequest | validation | func LogRequest(r *Request, v ...string) {
serializedHeaders := bytes.Buffer{}
r.Header.Write(&serializedHeaders)
printf := log.Printf
if Logger != nil {
printf = Logger.Printf
}
printf(
LogRequestTemplate,
strings.Join(v, " "),
r.URL.String(),
r.Method,
time.Now(),
serializedHeaders.String(),
s... | go | {
"resource": ""
} |
q173630 | CommonLogHandler | validation | func CommonLogHandler(logger *log.Logger, templ string, h http.Handler) http.Handler {
if logger == nil {
logger = log.New(os.Stdout, "", 0)
}
if templ == "" {
templ = CommonLogFormat
}
return &commonLogHandler{
handler: h,
logger: logger,
template: template.Must(template.New("").Parse(templ)),
}
} | go | {
"resource": ""
} |
q173631 | ServeHTTP | validation | func (lh *commonLogHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
// take a copy of the request (so it's immutable)
// watch the writer and capture the status and size
logData := LogData{
Request: *req,
Response: WatchResponseWriter(w),
}
logData.Start = time.Now()
lh.handler.ServeHTTP(logDa... | go | {
"resource": ""
} |
q173632 | UrlUsername | validation | func (this LogData) UrlUsername() string {
if this.Request.URL.User != nil {
return this.Request.URL.User.Username()
}
return ""
} | go | {
"resource": ""
} |
q173633 | UrlFor | validation | func UrlFor(name string, args ...string) *url.URL {
r := Router.Get(name)
if r == nil {
log.Panicf("UrlFor: No such route '%s'\n", name)
}
u, err := r.URL(args...)
if err != nil {
log.Panicln("UrlFor: " + err.Error())
}
return u
} | go | {
"resource": ""
} |
q173634 | AbsoluteUrlFor | validation | func AbsoluteUrlFor(name string, args ...string) *url.URL {
u := UrlFor(name, args...)
u.Host = UrlBase.Host
u.Scheme = UrlBase.Scheme
return u
} | go | {
"resource": ""
} |
q173635 | Parse | validation | func Parse(jsondata []byte, v interface{}) {
err := json.Unmarshal(jsondata, v)
if err != nil {
panic(err.Error())
}
} | go | {
"resource": ""
} |
q173636 | LoadFromEnv | validation | func LoadFromEnv(v interface{}, prefix string) (result []MarshalledEnvironmentVar) {
pointerValue := reflect.ValueOf(v)
structValue := pointerValue.Elem()
structType := structValue.Type()
for i := 0; i < structValue.NumField(); i++ {
structField := structType.Field(i)
fieldValue := structValue.Field(i)
if f... | go | {
"resource": ""
} |
q173637 | RegexPath | validation | func RegexPath(reg *regexp.Regexp, h http.Handler) http.Handler {
if reg == nil {
return h
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
matches := reg.FindStringSubmatch(r.URL.Path)
if len(matches) > 1 {
r.URL.Path = matches[1]
h.ServeHTTP(w, r)
} else {
http.NotFound(w,... | go | {
"resource": ""
} |
q173638 | CacheControl | validation | func CacheControl(maxage uint, delegate http.Handler) http.Handler {
return &cacheDecorator{delegate, maxage}
} | go | {
"resource": ""
} |
q173639 | transform | validation | func transform(in interface{}) (_ interface{}, err error) {
switch in.(type) {
case map[interface{}]interface{}:
o := make(map[string]interface{})
for k, v := range in.(map[interface{}]interface{}) {
sk := ""
switch k.(type) {
case string:
sk = k.(string)
case int:
sk = strconv.Itoa(k.(int))
... | go | {
"resource": ""
} |
q173640 | DiscoverWalk | validation | func DiscoverWalk(app App, insecure discovery.InsecureOption, discoverFn DiscoverWalkFunc) (err error) {
var (
eps *Endpoints
)
parts := strings.Split(string(app.Name), "/")
for i := range parts {
end := len(parts) - i
pre := strings.Join(parts[:end], "/")
eps, err = doDiscover(pre, app, insecure)
if de... | go | {
"resource": ""
} |
q173641 | DiscoverEndpoints | validation | func DiscoverEndpoints(app App, insecure discovery.InsecureOption) (out *Endpoints, attempts []FailedAttempt, err error) {
out = &Endpoints{}
testFn := func(pre string, eps *Endpoints, err error) error {
if len(out.ACIEndpoints) != 0 || len(out.Keys) != 0 || len(out.ACIPushEndpoints) != 0 {
return errEnough
}
... | go | {
"resource": ""
} |
q173642 | JSONFieldsFromStruct | validation | func JSONFieldsFromStruct(v reflect.Value) []string {
if v.Kind() != reflect.Struct {
return nil
}
m := getType2jfm(v.Type())
m.lock.Lock()
defer m.lock.Unlock()
l := make([]string, 0, len(m.fields))
for k := range m.fields {
l = append(l, k)
}
return l
} | go | {
"resource": ""
} |
q173643 | StructFieldFromJSONName | validation | func StructFieldFromJSONName(v reflect.Value, name string) string {
if v.Kind() != reflect.Struct {
return ""
}
m := getType2jfm(v.Type())
m.lock.Lock()
defer m.lock.Unlock()
s, ok := m.fields[name]
if !ok {
return ""
}
return s
} | go | {
"resource": ""
} |
q173644 | Enumerate | validation | func (dict Dictionary) Enumerate(cancel <-chan struct{}) Enumerator {
if dict.root == nil {
return Empty.Enumerate(cancel)
}
return dict.root.Enumerate(cancel)
} | go | {
"resource": ""
} |
q173645 | Release | validation | func (m *Message) Release() {
if m != nil {
m.Text = nil
m.List = m.List[:0]
messagePool.Put(m)
}
} | go | {
"resource": ""
} |
q173646 | Wrap | validation | func Wrap(err error, text ...string) Error {
return causer(newError(nil, err, text...))
} | go | {
"resource": ""
} |
q173647 | causer | validation | func causer(e *errorT) Error {
if e.err == nil {
return e
}
return &causerT{
errorT: e,
}
} | go | {
"resource": ""
} |
q173648 | From | validation | func From(ctx context.Context) Context {
if c, ok := ctx.(Context); ok {
return c
}
return &contextT{ctx: ctx}
} | go | {
"resource": ""
} |
q173649 | With | validation | func (c *contextT) With(keyvals ...interface{}) context.Context {
return &contextT{ctx: newContext(c.ctx, keyvals)}
} | go | {
"resource": ""
} |
q173650 | Format | validation | func (c *contextT) Format(f fmt.State, ch rune) {
if ch == 'v' && f.Flag('+') {
fmt.Fprint(f, c.ctx)
return
}
buf := pool.AllocBuffer()
list := List(fromContext(c.ctx))
list.writeToBuffer(buf)
f.Write(buf.Bytes())
pool.ReleaseBuffer(buf)
} | go | {
"resource": ""
} |
q173651 | NewWriter | validation | func NewWriter(out io.Writer) *Writer {
w := &Writer{
printer: newPrinter(out),
}
return w
} | go | {
"resource": ""
} |
q173652 | Levels | validation | func (w *Writer) Levels() map[string]string {
w.mutex.Lock()
defer w.mutex.Unlock()
if w.levels == nil {
w.setLevels(Levels)
}
levels := make(map[string]string)
for level, effect := range w.levels {
levels[level] = effect
}
return levels
} | go | {
"resource": ""
} |
q173653 | SetLevel | validation | func (w *Writer) SetLevel(level string, effect string) {
levels := w.Levels()
levels[level] = effect
w.SetLevels(levels)
} | go | {
"resource": ""
} |
q173654 | Suppress | validation | func (w *Writer) Suppress(levels ...string) {
p := w.Levels()
for _, level := range levels {
p[level] = "hide"
}
w.SetLevels(p)
} | go | {
"resource": ""
} |
q173655 | IsSuppressed | validation | func (w *Writer) IsSuppressed(level string) bool {
_, ok := w.suppressMap[level]
return ok
} | go | {
"resource": ""
} |
q173656 | Handle | validation | func (w *Writer) Handle(h Handler) {
w.mutex.Lock()
defer w.mutex.Unlock()
if h != nil {
w.handlers = append(w.handlers, h)
}
} | go | {
"resource": ""
} |
q173657 | SetOutput | validation | func (w *Writer) SetOutput(out io.Writer) {
w.mutex.Lock()
w.printer = newPrinter(out)
w.mutex.Unlock()
} | go | {
"resource": ""
} |
q173658 | Enumerate | validation | func (d Directory) Enumerate(cancel <-chan struct{}) Enumerator {
results := make(chan interface{})
go func() {
defer close(results)
filepath.Walk(d.Location, func(currentLocation string, info os.FileInfo, openErr error) (err error) {
if openErr != nil {
err = openErr
return
}
if d.Location ==... | go | {
"resource": ""
} |
q173659 | All | validation | func All(subject Enumerable, p Predicate) bool {
done := make(chan struct{})
defer close(done)
return subject.Enumerate(done).All(p)
} | go | {
"resource": ""
} |
q173660 | All | validation | func (iter Enumerator) All(p Predicate) bool {
for entry := range iter {
if !p(entry) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q173661 | Any | validation | func Any(iterator Enumerable) bool {
done := make(chan struct{})
defer close(done)
for range iterator.Enumerate(done) {
return true
}
return false
} | go | {
"resource": ""
} |
q173662 | Anyp | validation | func Anyp(iterator Enumerable, p Predicate) bool {
done := make(chan struct{})
defer close(done)
for element := range iterator.Enumerate(done) {
if p(element) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q173663 | AsEnumerable | validation | func AsEnumerable(entries ...interface{}) Enumerable {
if len(entries) != 1 {
return enumerableSlice(entries)
}
val := reflect.ValueOf(entries[0])
if kind := val.Kind(); kind == reflect.Slice || kind == reflect.Array {
return enumerableValue{
Value: val,
}
}
return enumerableSlice(entries)
} | go | {
"resource": ""
} |
q173664 | First | validation | func First(subject Enumerable) (retval interface{}, err error) {
done := make(chan struct{})
err = errNoElements
var isOpen bool
if retval, isOpen = <-subject.Enumerate(done); isOpen {
err = nil
}
close(done)
return
} | go | {
"resource": ""
} |
q173665 | Merge | validation | func (iter Enumerator) Merge(others ...Enumerator) Enumerator {
retval := make(chan interface{})
var wg sync.WaitGroup
wg.Add(len(others) + 1)
funnel := func(prevResult Enumerator) {
for entry := range prevResult {
retval <- entry
}
wg.Done()
}
go funnel(iter)
for _, item := range others {
go funne... | go | {
"resource": ""
} |
q173666 | ParallelSelect | validation | func ParallelSelect(original Enumerable, operation Transform) Enumerable {
return parallelSelecter{
original: original,
operation: operation,
}
} | go | {
"resource": ""
} |
q173667 | ParallelSelect | validation | func (iter Enumerator) ParallelSelect(operation Transform) Enumerator {
if cpus := runtime.NumCPU(); cpus != 1 {
intermediate := iter.splitN(operation, uint(cpus))
return intermediate[0].Merge(intermediate[1:]...)
}
return iter
} | go | {
"resource": ""
} |
q173668 | Reverse | validation | func (iter Enumerator) Reverse() Enumerator {
cache := NewStack()
for entry := range iter {
cache.Push(entry)
}
retval := make(chan interface{})
go func() {
for !cache.IsEmpty() {
val, _ := cache.Pop()
retval <- val
}
close(retval)
}()
return retval
} | go | {
"resource": ""
} |
q173669 | Select | validation | func Select(subject Enumerable, transform Transform) Enumerable {
return selecter{
original: subject,
transform: transform,
}
} | go | {
"resource": ""
} |
q173670 | Select | validation | func (iter Enumerator) Select(transform Transform) Enumerator {
retval := make(chan interface{})
go func() {
for item := range iter {
retval <- transform(item)
}
close(retval)
}()
return retval
} | go | {
"resource": ""
} |
q173671 | SelectMany | validation | func SelectMany(subject Enumerable, toMany Unfolder) Enumerable {
return selectManyer{
original: subject,
toMany: toMany,
}
} | go | {
"resource": ""
} |
q173672 | SelectMany | validation | func (iter Enumerator) SelectMany(lister Unfolder) Enumerator {
retval := make(chan interface{})
go func() {
for parent := range iter {
for child := range lister(parent) {
retval <- child
}
}
close(retval)
}()
return retval
} | go | {
"resource": ""
} |
q173673 | Single | validation | func Single(iter Enumerable) (retval interface{}, err error) {
done := make(chan struct{})
defer close(done)
err = errNoElements
firstPass := true
for entry := range iter.Enumerate(done) {
if firstPass {
retval = entry
err = nil
} else {
retval = nil
err = errMultipleElements
break
}
first... | go | {
"resource": ""
} |
q173674 | Singlep | validation | func Singlep(iter Enumerable, pred Predicate) (retval interface{}, err error) {
iter = Where(iter, pred)
return Single(iter)
} | go | {
"resource": ""
} |
q173675 | Skip | validation | func Skip(subject Enumerable, n uint) Enumerable {
return skipper{
original: subject,
skipCount: n,
}
} | go | {
"resource": ""
} |
q173676 | splitN | validation | func (iter Enumerator) splitN(operation Transform, n uint) []Enumerator {
results, cast := make([]chan interface{}, n, n), make([]Enumerator, n, n)
for i := uint(0); i < n; i++ {
results[i] = make(chan interface{})
cast[i] = results[i]
}
go func() {
for i := uint(0); i < n; i++ {
go func(addr uint) {
... | go | {
"resource": ""
} |
q173677 | Take | validation | func Take(subject Enumerable, n uint) Enumerable {
return taker{
original: subject,
n: n,
}
} | go | {
"resource": ""
} |
q173678 | Take | validation | func (iter Enumerator) Take(n uint) Enumerator {
results := make(chan interface{})
go func() {
defer close(results)
i := uint(0)
for entry := range iter {
if i >= n {
return
}
i++
results <- entry
}
}()
return results
} | go | {
"resource": ""
} |
q173679 | TakeWhile | validation | func TakeWhile(subject Enumerable, criteria func(interface{}, uint) bool) Enumerable {
return takeWhiler{
original: subject,
criteria: criteria,
}
} | go | {
"resource": ""
} |
q173680 | TakeWhile | validation | func (iter Enumerator) TakeWhile(criteria func(interface{}, uint) bool) Enumerator {
results := make(chan interface{})
go func() {
defer close(results)
i := uint(0)
for entry := range iter {
if !criteria(entry, i) {
return
}
i++
results <- entry
}
}()
return results
} | go | {
"resource": ""
} |
q173681 | Tee | validation | func (iter Enumerator) Tee() (Enumerator, Enumerator) {
left, right := make(chan interface{}), make(chan interface{})
go func() {
for entry := range iter {
left <- entry
right <- entry
}
close(left)
close(right)
}()
return left, right
} | go | {
"resource": ""
} |
q173682 | ToSlice | validation | func (iter Enumerator) ToSlice() []interface{} {
retval := make([]interface{}, 0)
for entry := range iter {
retval = append(retval, entry)
}
return retval
} | go | {
"resource": ""
} |
q173683 | Where | validation | func Where(original Enumerable, p Predicate) Enumerable {
return wherer{
original: original,
filter: p,
}
} | go | {
"resource": ""
} |
q173684 | Where | validation | func (iter Enumerator) Where(predicate Predicate) Enumerator {
retval := make(chan interface{})
go func() {
for item := range iter {
if predicate(item) {
retval <- item
}
}
close(retval)
}()
return retval
} | go | {
"resource": ""
} |
q173685 | ReleaseBuffer | validation | func ReleaseBuffer(buf *bytes.Buffer) {
if buf != nil {
buf.Reset()
bufferPool.Put(buf)
}
} | go | {
"resource": ""
} |
q173686 | NewStack | validation | func NewStack(entries ...interface{}) *Stack {
retval := &Stack{}
retval.underlyer = NewLinkedList()
for _, entry := range entries {
retval.Push(entry)
}
return retval
} | go | {
"resource": ""
} |
q173687 | Enumerate | validation | func (stack *Stack) Enumerate(cancel <-chan struct{}) Enumerator {
stack.key.RLock()
defer stack.key.RUnlock()
return stack.underlyer.Enumerate(cancel)
} | go | {
"resource": ""
} |
q173688 | IsEmpty | validation | func (stack *Stack) IsEmpty() bool {
stack.key.RLock()
defer stack.key.RUnlock()
return stack.underlyer == nil || stack.underlyer.IsEmpty()
} | go | {
"resource": ""
} |
q173689 | Push | validation | func (stack *Stack) Push(entry interface{}) {
stack.key.Lock()
defer stack.key.Unlock()
if nil == stack.underlyer {
stack.underlyer = NewLinkedList()
}
stack.underlyer.AddFront(entry)
} | go | {
"resource": ""
} |
q173690 | Pop | validation | func (stack *Stack) Pop() (interface{}, bool) {
stack.key.Lock()
defer stack.key.Unlock()
if nil == stack.underlyer {
return nil, false
}
return stack.underlyer.RemoveFront()
} | go | {
"resource": ""
} |
q173691 | Peek | validation | func (stack *Stack) Peek() (interface{}, bool) {
stack.key.RLock()
defer stack.key.RUnlock()
return stack.underlyer.PeekFront()
} | go | {
"resource": ""
} |
q173692 | Size | validation | func (stack *Stack) Size() uint {
stack.key.RLock()
defer stack.key.RUnlock()
if stack.underlyer == nil {
return 0
}
return stack.underlyer.Length()
} | go | {
"resource": ""
} |
q173693 | NewLinkedList | validation | func NewLinkedList(entries ...interface{}) *LinkedList {
list := &LinkedList{}
for _, entry := range entries {
list.AddBack(entry)
}
return list
} | go | {
"resource": ""
} |
q173694 | AddBack | validation | func (list *LinkedList) AddBack(entry interface{}) {
toAppend := &llNode{
payload: entry,
}
list.key.Lock()
defer list.key.Unlock()
list.length++
if list.first == nil {
list.first = toAppend
list.last = toAppend
return
}
list.last.next = toAppend
list.last = toAppend
} | go | {
"resource": ""
} |
q173695 | Enumerate | validation | func (list *LinkedList) Enumerate(cancel <-chan struct{}) Enumerator {
retval := make(chan interface{})
go func() {
list.key.RLock()
defer list.key.RUnlock()
defer close(retval)
current := list.first
for current != nil {
select {
case retval <- current.payload:
break
case <-cancel:
return... | go | {
"resource": ""
} |
q173696 | Get | validation | func (list *LinkedList) Get(pos uint) (interface{}, bool) {
list.key.RLock()
defer list.key.RUnlock()
node, ok := get(list.first, pos)
if ok {
return node.payload, true
}
return nil, false
} | go | {
"resource": ""
} |
q173697 | IsEmpty | validation | func (list *LinkedList) IsEmpty() bool {
list.key.RLock()
defer list.key.RUnlock()
return list.first == nil
} | go | {
"resource": ""
} |
q173698 | Length | validation | func (list *LinkedList) Length() uint {
list.key.RLock()
defer list.key.RUnlock()
return list.length
} | go | {
"resource": ""
} |
q173699 | PeekBack | validation | func (list *LinkedList) PeekBack() (interface{}, bool) {
list.key.RLock()
defer list.key.RUnlock()
if list.last == nil {
return nil, false
}
return list.last.payload, true
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.