_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q36200 | Flatten | train | func (set *Set) Flatten() []interface{} {
set.lock.Lock()
defer set.lock.Unlock()
if set.flattened != nil {
return set.flattened
}
set.flattened = make([]interface{}, 0, len(set.items))
for item := range set.items {
set.flattened = append(set.flattened, item)
}
return set.flattened
} | go | {
"resource": ""
} |
q36201 | Len | train | func (set *Set) Len() int64 {
set.lock.RLock()
size := int64(len(set.items))
set.lock.RUnlock()
return size
} | go | {
"resource": ""
} |
q36202 | Clear | train | func (set *Set) Clear() {
set.lock.Lock()
set.items = map[interface{}]struct{}{}
set.lock.Unlock()
} | go | {
"resource": ""
} |
q36203 | All | train | func (set *Set) All(items ...interface{}) bool {
set.lock.RLock()
defer set.lock.RUnlock()
for _, item := range items {
if _, ok := set.items[item]; !ok {
return false
}
}
return true
} | go | {
"resource": ""
} |
q36204 | Dispose | train | func (set *Set) Dispose() {
set.lock.Lock()
defer set.lock.Unlock()
for k := range set.items {
delete(set.items, k)
}
//this is so we don't hang onto any references
for i := 0; i < len(set.flattened); i++ {
set.flattened[i] = nil
}
set.flattened = set.flattened[:0]
pool.Put(set)
} | go | {
"resource": ""
} |
q36205 | New | train | func New(items ...interface{}) *Set {
set := pool.Get().(*Set)
for _, item := range items {
set.items[item] = struct{}{}
}
if len(items) > 0 {
set.flattened = nil
}
return set
} | go | {
"resource": ""
} |
q36206 | Dispose | train | func (ivs *Intervals) Dispose() {
for i := 0; i < len(*ivs); i++ {
(*ivs)[i] = nil
}
*ivs = (*ivs)[:0]
intervalsPool.Put(*ivs)
} | go | {
"resource": ""
} |
q36207 | Next | train | func (iter *iterator) Next() bool {
if iter.first {
iter.first = false
return iter.n != nil
}
if iter.n == nil {
return false
}
iter.n = iter.n.forward[0]
return iter.n != nil
} | go | {
"resource": ""
} |
q36208 | Value | train | func (iter *iterator) Value() common.Comparator {
if iter.n == nil {
return nil
}
return iter.n.entry
} | go | {
"resource": ""
} |
q36209 | exhaust | train | func (iter *iterator) exhaust() common.Comparators {
entries := make(common.Comparators, 0, 10)
for i := iter; i.Next(); {
entries = append(entries, i.Value())
}
return entries
} | go | {
"resource": ""
} |
q36210 | WaitChan | train | func (f *Selectable) WaitChan() <-chan struct{} {
if atomic.LoadUint32(&f.filled) == 1 {
return closed
}
return f.wchan()
} | go | {
"resource": ""
} |
q36211 | GetResult | train | func (f *Selectable) GetResult() (interface{}, error) {
if atomic.LoadUint32(&f.filled) == 0 {
<-f.wchan()
}
return f.val, f.err
} | go | {
"resource": ""
} |
q36212 | Fill | train | func (f *Selectable) Fill(v interface{}, e error) error {
f.m.Lock()
if f.filled == 0 {
f.val = v
f.err = e
atomic.StoreUint32(&f.filled, 1)
w := f.wait
f.wait = closed
if w != nil {
close(w)
}
}
f.m.Unlock()
return f.err
} | go | {
"resource": ""
} |
q36213 | Put | train | func (q *Queue) Put(items ...interface{}) error {
if len(items) == 0 {
return nil
}
q.lock.Lock()
if q.disposed {
q.lock.Unlock()
return ErrDisposed
}
q.items = append(q.items, items...)
for {
sema := q.waiters.get()
if sema == nil {
break
}
sema.response.Add(1)
select {
case sema.ready <... | go | {
"resource": ""
} |
q36214 | Poll | train | func (q *Queue) Poll(number int64, timeout time.Duration) ([]interface{}, error) {
if number < 1 {
// thanks again go
return []interface{}{}, nil
}
q.lock.Lock()
if q.disposed {
q.lock.Unlock()
return nil, ErrDisposed
}
var items []interface{}
if len(q.items) == 0 {
sema := newSema()
q.waiters.pu... | go | {
"resource": ""
} |
q36215 | Peek | train | func (q *Queue) Peek() (interface{}, error) {
q.lock.Lock()
defer q.lock.Unlock()
if q.disposed {
return nil, ErrDisposed
}
peekItem, ok := q.items.peek()
if !ok {
return nil, ErrEmptyQueue
}
return peekItem, nil
} | go | {
"resource": ""
} |
q36216 | TakeUntil | train | func (q *Queue) TakeUntil(checker func(item interface{}) bool) ([]interface{}, error) {
if checker == nil {
return nil, nil
}
q.lock.Lock()
if q.disposed {
q.lock.Unlock()
return nil, ErrDisposed
}
result := q.items.getUntil(checker)
q.lock.Unlock()
return result, nil
} | go | {
"resource": ""
} |
q36217 | Empty | train | func (q *Queue) Empty() bool {
q.lock.Lock()
defer q.lock.Unlock()
return len(q.items) == 0
} | go | {
"resource": ""
} |
q36218 | Len | train | func (q *Queue) Len() int64 {
q.lock.Lock()
defer q.lock.Unlock()
return int64(len(q.items))
} | go | {
"resource": ""
} |
q36219 | Disposed | train | func (q *Queue) Disposed() bool {
q.lock.Lock()
defer q.lock.Unlock()
return q.disposed
} | go | {
"resource": ""
} |
q36220 | Dispose | train | func (q *Queue) Dispose() []interface{} {
q.lock.Lock()
defer q.lock.Unlock()
q.disposed = true
for _, waiter := range q.waiters {
waiter.response.Add(1)
select {
case waiter.ready <- true:
// release Poll immediately
default:
// ignore if it's a timeout or in the get
}
}
disposedItems := q.item... | go | {
"resource": ""
} |
q36221 | New | train | func New(hasher func(v interface{}) uint32) *Dtrie {
if hasher == nil {
hasher = defaultHasher
}
return &Dtrie{
root: emptyNode(0, 32),
hasher: hasher,
}
} | go | {
"resource": ""
} |
q36222 | Size | train | func (d *Dtrie) Size() (size int) {
for _ = range iterate(d.root, nil) {
size++
}
return size
} | go | {
"resource": ""
} |
q36223 | Get | train | func (d *Dtrie) Get(key interface{}) interface{} {
return get(d.root, d.hasher(key), key).Value()
} | go | {
"resource": ""
} |
q36224 | Insert | train | func (d *Dtrie) Insert(key, value interface{}) *Dtrie {
root := insert(d.root, &entry{d.hasher(key), key, value})
return &Dtrie{root, d.hasher}
} | go | {
"resource": ""
} |
q36225 | Remove | train | func (d *Dtrie) Remove(key interface{}) *Dtrie {
root := remove(d.root, d.hasher(key), key)
return &Dtrie{root, d.hasher}
} | go | {
"resource": ""
} |
q36226 | filter | train | func (t *Tr) filter(start, stop interface{}, n *Node, fn func(key *Key) bool) bool {
for iter := n.iter(t.config.Comparator, start, stop); iter.next(); {
id, _ := iter.value()
if !fn(id) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q36227 | iterativeFind | train | func (t *Tr) iterativeFind(value interface{}, id ID) (*path, error) {
if len(id) == 0 { // can't find a matching node
return nil, nil
}
path := &path{}
var n *Node
var err error
var i int
var key *Key
for {
n, err = t.contextOrCachedNode(id, t.mutable)
if err != nil {
return nil, err
}
key, i = ... | go | {
"resource": ""
} |
q36228 | isInternal | train | func isInternal(n *node) bool {
if n == nil {
return false
}
return n.entry == nil
} | go | {
"resource": ""
} |
q36229 | hasInternal | train | func hasInternal(n *node) bool {
return isInternal(n.children[0]) || isInternal(n.children[1])
} | go | {
"resource": ""
} |
q36230 | newNode | train | func newNode(parent *node, entry Entry) *node {
return &node{
children: [2]*node{},
entry: entry,
parent: parent,
}
} | go | {
"resource": ""
} |
q36231 | binarySearchHashMaps | train | func binarySearchHashMaps(layers []map[uint64]*node, key uint64) (int, *node) {
low, high := 0, len(layers)-1
diff := 64 - len(layers)
var mid int
var node *node
for low <= high {
mid = (low + high) / 2
n, ok := layers[mid][key&masks[diff+mid]]
if ok {
node = n
low = mid + 1
} else {
high = mid - ... | go | {
"resource": ""
} |
q36232 | init | train | func (xft *XFastTrie) init(intType interface{}) {
bits := uint8(0)
switch intType.(type) {
case uint8:
bits = 8
case uint16:
bits = 16
case uint32:
bits = 32
case uint, uint64:
bits = 64
default:
// we'll panic with a bad value to the constructor.
panic(`Invalid universe size provided.`)
}
xft.lay... | go | {
"resource": ""
} |
q36233 | walkUpSuccessor | train | func (xft *XFastTrie) walkUpSuccessor(root, node, successor *node) {
n := successor.parent
for n != nil && n != root {
// we don't really want to overwrite existing internal nodes,
// or where the child is a leaf that is the successor
if !isInternal(n.children[0]) && n.children[0] != successor {
n.children[0... | go | {
"resource": ""
} |
q36234 | walkUpPredecessor | train | func (xft *XFastTrie) walkUpPredecessor(root, node, predecessor *node) {
n := predecessor.parent
for n != nil && n != root {
if !isInternal(n.children[1]) && n.children[1] != predecessor {
n.children[1] = node
}
n = n.parent
}
} | go | {
"resource": ""
} |
q36235 | walkUpNode | train | func (xft *XFastTrie) walkUpNode(root, node, predecessor, successor *node) {
n := node.parent
for n != nil && n != root {
if !isInternal(n.children[1]) && n.children[1] != successor && n.children[1] != node {
n.children[1] = successor
}
if !isInternal(n.children[0]) && n.children[0] != predecessor && n.child... | go | {
"resource": ""
} |
q36236 | predecessor | train | func (xft *XFastTrie) predecessor(key uint64) *node {
if xft.root == nil || xft.max == nil { // no successor if no nodes
return nil
}
if key >= xft.max.entry.Key() {
return xft.max
}
if key < xft.min.entry.Key() {
return nil
}
n := xft.layers[xft.bits-1][key]
if n != nil {
return n
}
layer, n := b... | go | {
"resource": ""
} |
q36237 | Iter | train | func (xft *XFastTrie) Iter(key uint64) *Iterator {
return &Iterator{
n: xft.successor(key),
first: true,
}
} | go | {
"resource": ""
} |
q36238 | Raw | train | func (b *Bot) Raw(method string, payload interface{}) ([]byte, error) {
url := fmt.Sprintf("%s/bot%s/%s", b.URL, b.Token, method)
var buf bytes.Buffer
if err := json.NewEncoder(&buf).Encode(payload); err != nil {
return []byte{}, wrapSystem(err)
}
resp, err := b.client.Post(url, "application/json", &buf)
if e... | go | {
"resource": ""
} |
q36239 | IsForwarded | train | func (m *Message) IsForwarded() bool {
return m.OriginalSender != nil || m.OriginalChat != nil
} | go | {
"resource": ""
} |
q36240 | FromGroup | train | func (m *Message) FromGroup() bool {
return m.Chat.Type == ChatGroup || m.Chat.Type == ChatSuperGroup
} | go | {
"resource": ""
} |
q36241 | IsService | train | func (m *Message) IsService() bool {
fact := false
fact = fact || m.UserJoined != nil
fact = fact || len(m.UsersJoined) > 0
fact = fact || m.UserLeft != nil
fact = fact || m.NewGroupTitle != ""
fact = fact || m.NewGroupPhoto != nil
fact = fact || m.GroupPhotoDeleted
fact = fact || m.GroupCreated || m.SuperGrou... | go | {
"resource": ""
} |
q36242 | UnmarshalJSON | train | func (p *Photo) UnmarshalJSON(jsonStr []byte) error {
var hq photoSize
if jsonStr[0] == '{' {
if err := json.Unmarshal(jsonStr, &hq); err != nil {
return err
}
} else {
var sizes []photoSize
if err := json.Unmarshal(jsonStr, &sizes); err != nil {
return err
}
hq = sizes[len(sizes)-1]
}
p.File... | go | {
"resource": ""
} |
q36243 | ServeHTTP | train | func (h *Webhook) ServeHTTP(w http.ResponseWriter, r *http.Request) {
var update Update
err := json.NewDecoder(r.Body).Decode(&update)
if err != nil {
h.bot.debug(fmt.Errorf("cannot decode update: %v", err))
return
}
h.dest <- update
} | go | {
"resource": ""
} |
q36244 | AdminRights | train | func AdminRights() Rights {
return Rights{
true, true, true, true, true, // 1-5
true, true, true, true, true, // 6-10
true, true, true} // 11-13
} | go | {
"resource": ""
} |
q36245 | Ban | train | func (b *Bot) Ban(chat *Chat, member *ChatMember) error {
params := map[string]string{
"chat_id": chat.Recipient(),
"user_id": member.User.Recipient(),
"until_date": strconv.FormatInt(member.RestrictedUntil, 10),
}
respJSON, err := b.Raw("kickChatMember", params)
if err != nil {
return err
}
retur... | go | {
"resource": ""
} |
q36246 | Unban | train | func (b *Bot) Unban(chat *Chat, user *User) error {
params := map[string]string{
"chat_id": chat.Recipient(),
"user_id": user.Recipient(),
}
respJSON, err := b.Raw("unbanChatMember", params)
if err != nil {
return err
}
return extractOkResponse(respJSON)
} | go | {
"resource": ""
} |
q36247 | AdminsOf | train | func (b *Bot) AdminsOf(chat *Chat) ([]ChatMember, error) {
params := map[string]string{
"chat_id": chat.Recipient(),
}
respJSON, err := b.Raw("getChatAdministrators", params)
if err != nil {
return nil, err
}
var resp struct {
Ok bool
Result []ChatMember
Description string `json:"descrip... | go | {
"resource": ""
} |
q36248 | NewMiddlewarePoller | train | func NewMiddlewarePoller(original Poller, filter func(*Update) bool) *MiddlewarePoller {
return &MiddlewarePoller{
Poller: original,
Filter: filter,
}
} | go | {
"resource": ""
} |
q36249 | Poll | train | func (p *MiddlewarePoller) Poll(b *Bot, dest chan Update, stop chan struct{}) {
cap := 1
if p.Capacity > 1 {
cap = p.Capacity
}
middle := make(chan Update, cap)
stopPoller := make(chan struct{})
go p.Poller.Poll(b, middle, stopPoller)
for {
select {
// call to stop
case <-stop:
stopPoller <- struct... | go | {
"resource": ""
} |
q36250 | Poll | train | func (p *LongPoller) Poll(b *Bot, dest chan Update, stop chan struct{}) {
go func(stop chan struct{}) {
<-stop
close(stop)
}(stop)
for {
updates, err := b.getUpdates(p.LastUpdateID+1, p.Timeout)
if err != nil {
b.debug(ErrCouldNotUpdate)
continue
}
for _, update := range updates {
p.LastUpdat... | go | {
"resource": ""
} |
q36251 | MarshalJSON | train | func (results Results) MarshalJSON() ([]byte, error) {
for _, result := range results {
if result.ResultID() == "" {
result.SetResultID(fmt.Sprintf("%d", &result))
}
if err := inferIQR(result); err != nil {
return nil, err
}
}
return json.Marshal([]Result(results))
} | go | {
"resource": ""
} |
q36252 | Add | train | func (c *Chain) Add(filter interface{}) {
switch filter.(type) {
case Filter:
break
case FilterFunc:
break
case func(*Update) bool:
break
default:
panic("telebot: unsupported filter type")
}
c.Filters = append(c.Filters, filter)
} | go | {
"resource": ""
} |
q36253 | NewBot | train | func NewBot(pref Settings) (*Bot, error) {
if pref.Updates == 0 {
pref.Updates = 100
}
client := pref.Client
if client == nil {
client = http.DefaultClient
}
if pref.URL == "" {
pref.URL = DefaultApiURL
}
bot := &Bot{
Token: pref.Token,
URL: pref.URL,
Updates: make(chan Update, pref.Updates... | go | {
"resource": ""
} |
q36254 | EditCaption | train | func (b *Bot) EditCaption(originalMsg Editable, caption string) (*Message, error) {
messageID, chatID := originalMsg.MessageSig()
params := map[string]string{"caption": caption}
// if inline message
if chatID == 0 {
params["inline_message_id"] = messageID
} else {
params["chat_id"] = strconv.FormatInt(chatID... | go | {
"resource": ""
} |
q36255 | Notify | train | func (b *Bot) Notify(recipient Recipient, action ChatAction) error {
params := map[string]string{
"chat_id": recipient.Recipient(),
"action": string(action),
}
respJSON, err := b.Raw("sendChatAction", params)
if err != nil {
return err
}
return extractOkResponse(respJSON)
} | go | {
"resource": ""
} |
q36256 | Accept | train | func (b *Bot) Accept(query *PreCheckoutQuery, errorMessage ...string) error {
params := map[string]string{
"pre_checkout_query_id": query.ID,
}
if len(errorMessage) == 0 {
params["ok"] = "True"
} else {
params["ok"] = "False"
params["error_message"] = errorMessage[0]
}
respJSON, err := b.Raw("answerPreC... | go | {
"resource": ""
} |
q36257 | Answer | train | func (b *Bot) Answer(query *Query, response *QueryResponse) error {
response.QueryID = query.ID
for _, result := range response.Results {
result.Process()
}
respJSON, err := b.Raw("answerInlineQuery", response)
if err != nil {
return err
}
return extractOkResponse(respJSON)
} | go | {
"resource": ""
} |
q36258 | FileByID | train | func (b *Bot) FileByID(fileID string) (File, error) {
params := map[string]string{
"file_id": fileID,
}
respJSON, err := b.Raw("getFile", params)
if err != nil {
return File{}, err
}
var resp struct {
Ok bool
Description string
Result File
}
err = json.Unmarshal(respJSON, &resp)
if e... | go | {
"resource": ""
} |
q36259 | Download | train | func (b *Bot) Download(file *File, localFilename string) error {
reader, err := b.GetFile(file)
if err != nil {
return wrapSystem(err)
}
defer reader.Close()
out, err := os.Create(localFilename)
if err != nil {
return wrapSystem(err)
}
defer out.Close()
_, err = io.Copy(out, reader)
if err != nil {
re... | go | {
"resource": ""
} |
q36260 | GetFile | train | func (b *Bot) GetFile(file *File) (io.ReadCloser, error) {
f, err := b.FileByID(file.FileID)
if err != nil {
return nil, err
}
url := fmt.Sprintf("%s/file/bot%s/%s",
b.URL, b.Token, f.FilePath)
resp, err := http.Get(url)
if err != nil {
return nil, err
}
// set FilePath
*file = f
return resp.Body, ni... | go | {
"resource": ""
} |
q36261 | StopLiveLocation | train | func (b *Bot) StopLiveLocation(message Editable, options ...interface{}) (*Message, error) {
messageID, chatID := message.MessageSig()
params := map[string]string{
"chat_id": fmt.Sprintf("%d", chatID),
"message_id": messageID,
}
sendOpts := extractOptions(options)
embedSendOptions(params, sendOpts)
resp... | go | {
"resource": ""
} |
q36262 | SetGroupTitle | train | func (b *Bot) SetGroupTitle(chat *Chat, newTitle string) error {
params := map[string]string{
"chat_id": chat.Recipient(),
"title": newTitle,
}
respJSON, err := b.Raw("setChatTitle", params)
if err != nil {
return err
}
return extractOkResponse(respJSON)
} | go | {
"resource": ""
} |
q36263 | SetGroupPhoto | train | func (b *Bot) SetGroupPhoto(chat *Chat, p *Photo) error {
params := map[string]string{
"chat_id": chat.Recipient(),
}
respJSON, err := b.sendFiles("setChatPhoto", map[string]File{"photo": p.File}, params)
if err != nil {
return err
}
return extractOkResponse(respJSON)
} | go | {
"resource": ""
} |
q36264 | Pin | train | func (b *Bot) Pin(message Editable, options ...interface{}) error {
messageID, chatID := message.MessageSig()
params := map[string]string{
"chat_id": strconv.FormatInt(chatID, 10),
"message_id": messageID,
}
sendOpts := extractOptions(options)
embedSendOptions(params, sendOpts)
respJSON, err := b.Raw("p... | go | {
"resource": ""
} |
q36265 | ChatByID | train | func (b *Bot) ChatByID(id string) (*Chat, error) {
params := map[string]string{
"chat_id": id,
}
respJSON, err := b.Raw("getChat", params)
if err != nil {
return nil, err
}
var resp struct {
Ok bool
Description string
Result *Chat
}
err = json.Unmarshal(respJSON, &resp)
if err != nil... | go | {
"resource": ""
} |
q36266 | ProfilePhotosOf | train | func (b *Bot) ProfilePhotosOf(user *User) ([]Photo, error) {
params := map[string]string{
"user_id": user.Recipient(),
}
respJSON, err := b.Raw("getUserProfilePhotos", params)
if err != nil {
return nil, err
}
var resp struct {
Ok bool
Result struct {
Count int `json:"total_count"`
Photos... | go | {
"resource": ""
} |
q36267 | FileURLByID | train | func (b *Bot) FileURLByID(fileID string) (string, error) {
f, err := b.FileByID(fileID)
if err != nil {
return "", err
}
return fmt.Sprintf("%s/file/bot%s/%s", b.URL, b.Token, f.FilePath), nil
} | go | {
"resource": ""
} |
q36268 | OnDisk | train | func (f *File) OnDisk() bool {
if _, err := os.Stat(f.FileLocal); err != nil {
return false
}
return true
} | go | {
"resource": ""
} |
q36269 | NewCPUShare | train | func NewCPUShare(i int) (CPUShare, error) {
if i < 2 {
return 0, ErrInvalidCPUShare
}
return CPUShare(i), nil
} | go | {
"resource": ""
} |
q36270 | ParseMemory | train | func ParseMemory(s string) (Memory, error) {
i, err := parseMemory(s)
return Memory(i), err
} | go | {
"resource": ""
} |
q36271 | BeforeCreate | train | func (r *Release) BeforeCreate() error {
t := timex.Now()
r.CreatedAt = &t
return nil
} | go | {
"resource": ""
} |
q36272 | DefaultRange | train | func (q ReleasesQuery) DefaultRange() headerutil.Range {
sort, order := "version", "desc"
return headerutil.Range{
Sort: &sort,
Order: &order,
}
} | go | {
"resource": ""
} |
q36273 | CreateAndRelease | train | func (s *releasesService) CreateAndRelease(ctx context.Context, db *gorm.DB, r *Release, ss twelvefactor.StatusStream) (*Release, error) {
r, err := s.Create(ctx, db, r)
if err != nil {
return r, err
}
// Schedule the new release onto the cluster.
return r, s.Release(ctx, r, ss)
} | go | {
"resource": ""
} |
q36274 | Create | train | func (s *releasesService) Create(ctx context.Context, db *gorm.DB, r *Release) (*Release, error) {
// Lock all releases for the given application to ensure that the
// release version is updated automically.
if err := db.Exec(`select 1 from releases where app_id = ? for update`, r.App.ID).Error; err != nil {
retur... | go | {
"resource": ""
} |
q36275 | Rollback | train | func (s *releasesService) Rollback(ctx context.Context, db *gorm.DB, opts RollbackOpts) (*Release, error) {
app, version := opts.App, opts.Version
r, err := releasesFind(db, ReleasesQuery{App: app, Version: &version})
if err != nil {
return nil, err
}
desc := fmt.Sprintf("Rollback to v%d", version)
desc = appe... | go | {
"resource": ""
} |
q36276 | Release | train | func (s *releasesService) Release(ctx context.Context, release *Release, ss twelvefactor.StatusStream) error {
a, err := newSchedulerApp(release)
if err != nil {
return err
}
return s.Scheduler.Submit(ctx, a, ss)
} | go | {
"resource": ""
} |
q36277 | Restart | train | func (s *releasesService) Restart(ctx context.Context, db *gorm.DB, app *App) error {
return s.Scheduler.Restart(ctx, app.ID, nil)
} | go | {
"resource": ""
} |
q36278 | releasesFind | train | func releasesFind(db *gorm.DB, scope scope) (*Release, error) {
var release Release
scope = composedScope{releasesPreload, scope}
if err := first(db, scope, &release); err != nil {
return &release, err
}
return &release, nil
} | go | {
"resource": ""
} |
q36279 | releases | train | func releases(db *gorm.DB, scope scope) ([]*Release, error) {
var releases []*Release
scope = composedScope{releasesPreload, scope}
return releases, find(db, scope, &releases)
} | go | {
"resource": ""
} |
q36280 | currentFormation | train | func currentFormation(db *gorm.DB, app *App) (Formation, error) {
// Get the current release
current, err := releasesFind(db, ReleasesQuery{App: app})
if err != nil {
return nil, err
}
f := current.Formation
return f, nil
} | go | {
"resource": ""
} |
q36281 | releasesLastVersion | train | func releasesLastVersion(db *gorm.DB, appID string) (int, error) {
var version int
rows, err := db.Raw(`select version from releases where app_id = ? order by version desc`, appID).Rows()
if err != nil {
return version, err
}
defer rows.Close()
for rows.Next() {
err := rows.Scan(&version)
return version, ... | go | {
"resource": ""
} |
q36282 | releasesCreate | train | func releasesCreate(db *gorm.DB, release *Release) (*Release, error) {
// Get the last release version for this app.
v, err := releasesLastVersion(db, release.App.ID)
if err != nil {
return release, err
}
// Increment the release version.
release.Version = v + 1
if err := db.Create(release).Error; err != nil... | go | {
"resource": ""
} |
q36283 | standardWebExposure | train | func standardWebExposure(app *App) *twelvefactor.Exposure {
ports := []twelvefactor.Port{
{
Container: 8080,
Host: 80,
Protocol: &twelvefactor.HTTP{},
},
}
// If a certificate is attached to the "web" process, add an SSL port.
if cert, ok := app.Certs[webProcessType]; ok {
ports = append(ports... | go | {
"resource": ""
} |
q36284 | ServeHTTP | train | func (idp *IdentityProvider) ServeHTTP(w http.ResponseWriter, r *http.Request) {
metadataURL, err := url.Parse(idp.MetadataURL)
if err != nil {
panic(err)
}
ssoURL, err := url.Parse(idp.SSOURL)
if err != nil {
panic(err)
}
switch r.URL.Path {
case metadataURL.Path:
idp.ServeMetadata(w, r)
case ssoURL.Pa... | go | {
"resource": ""
} |
q36285 | ServeMetadata | train | func (idp *IdentityProvider) ServeMetadata(w http.ResponseWriter, r *http.Request) {
buf, _ := xml.MarshalIndent(idp.Metadata(), "", " ")
w.Header().Set("Content-Type", "application/samlmetadata+xml")
w.Write(buf)
} | go | {
"resource": ""
} |
q36286 | ServeSSO | train | func (idp *IdentityProvider) ServeSSO(w http.ResponseWriter, r *http.Request) {
req, err := NewIdpAuthnRequest(idp, r)
if err != nil {
log.Printf("failed to parse request: %s", err)
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
if err := req.Validate(); err != nil {
... | go | {
"resource": ""
} |
q36287 | NewIdpAuthnRequest | train | func NewIdpAuthnRequest(idp *IdentityProvider, r *http.Request) (*IdpAuthnRequest, error) {
req := &IdpAuthnRequest{
IDP: idp,
HTTPRequest: r,
}
switch r.Method {
case "GET":
compressedRequest, err := base64.StdEncoding.DecodeString(r.URL.Query().Get("SAMLRequest"))
if err != nil {
return nil, f... | go | {
"resource": ""
} |
q36288 | MarshalAssertion | train | func (req *IdpAuthnRequest) MarshalAssertion() error {
buf, err := xml.Marshal(req.Assertion)
if err != nil {
return err
}
buf, err = xmlsec.Sign([]byte(req.IDP.Key),
buf, xmlsec.SignatureOptions{})
if err != nil {
return err
}
buf, err = xmlsec.Encrypt(getSPEncryptionCert(req.ServiceProviderMetadata),
... | go | {
"resource": ""
} |
q36289 | Ref | train | func Ref(ref interface{}) interface{} {
switch v := ref.(type) {
case NamedResource:
ref = v.Name
}
return map[string]interface{}{"Ref": ref}
} | go | {
"resource": ""
} |
q36290 | GetAtt | train | func GetAtt(ref, attr interface{}) interface{} {
switch v := ref.(type) {
case NamedResource:
ref = v.Name
}
return map[string][]interface{}{"Fn::GetAtt": []interface{}{ref, attr}}
} | go | {
"resource": ""
} |
q36291 | LogDrainCreate | train | func (c *Client) LogDrainCreate(appIdentity string, url string) (*LogDrain, error) {
params := struct {
URL string `json:"url"`
}{
URL: url,
}
var logDrainRes LogDrain
return &logDrainRes, c.Post(&logDrainRes, "/apps/"+appIdentity+"/log-drains", params)
} | go | {
"resource": ""
} |
q36292 | LogDrainDelete | train | func (c *Client) LogDrainDelete(appIdentity string, logDrainIdentity string) error {
return c.Delete("/apps/" + appIdentity + "/log-drains/" + logDrainIdentity)
} | go | {
"resource": ""
} |
q36293 | LogDrainInfo | train | func (c *Client) LogDrainInfo(appIdentity string, logDrainIdentity string) (*LogDrain, error) {
var logDrain LogDrain
return &logDrain, c.Get(&logDrain, "/apps/"+appIdentity+"/log-drains/"+logDrainIdentity)
} | go | {
"resource": ""
} |
q36294 | LogDrainList | train | func (c *Client) LogDrainList(appIdentity string, lr *ListRange) ([]LogDrain, error) {
req, err := c.NewRequest("GET", "/apps/"+appIdentity+"/log-drains", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var logDrainsRes []LogDrain
return logDrainsRes, c.DoReq(req, &logDrainsR... | go | {
"resource": ""
} |
q36295 | RegionInfo | train | func (c *Client) RegionInfo(regionIdentity string) (*Region, error) {
var region Region
return ®ion, c.Get(®ion, "/regions/"+regionIdentity)
} | go | {
"resource": ""
} |
q36296 | RegionList | train | func (c *Client) RegionList(lr *ListRange) ([]Region, error) {
req, err := c.NewRequest("GET", "/regions", nil, nil)
if err != nil {
return nil, err
}
if lr != nil {
lr.SetHeader(req)
}
var regionsRes []Region
return regionsRes, c.DoReq(req, ®ionsRes)
} | go | {
"resource": ""
} |
q36297 | CacheAuthorization | train | func CacheAuthorization(a Authorizer, expiration time.Duration) Authorizer {
cache := cache.New(expiration, 30*time.Second)
return &cachedAuthorizer{
Authorizer: a,
cache: cache,
}
} | go | {
"resource": ""
} |
q36298 | DynoRestart | train | func (c *Client) DynoRestart(appIdentity, dynoIdentity, message string) error {
rh := RequestHeaders{CommitMessage: message}
return c.DeleteWithHeaders("/apps/"+appIdentity+"/dynos/"+dynoIdentity, rh.Headers())
} | go | {
"resource": ""
} |
q36299 | DynoRestartAll | train | func (c *Client) DynoRestartAll(appIdentity, message string) error {
rh := RequestHeaders{CommitMessage: message}
return c.DeleteWithHeaders("/apps/"+appIdentity+"/dynos", rh.Headers())
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.