_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q37400 | makeNameInArchive | train | func makeNameInArchive(sourceInfo os.FileInfo, source, baseDir, fpath string) (string, error) {
name := filepath.Base(fpath) // start with the file or dir name
if sourceInfo.IsDir() {
// preserve internal directory structure; that's the path components
// between the source directory's leaf and this file's leaf
... | go | {
"resource": ""
} |
q37401 | NameInArchive | train | func NameInArchive(sourceInfo os.FileInfo, source, fpath string) (string, error) {
return makeNameInArchive(sourceInfo, source, "", fpath)
} | go | {
"resource": ""
} |
q37402 | ByExtension | train | func ByExtension(filename string) (interface{}, error) {
var ec interface{}
for _, c := range extCheckers {
if err := c.CheckExt(filename); err == nil {
ec = c
break
}
}
switch ec.(type) {
case *Rar:
return NewRar(), nil
case *Tar:
return NewTar(), nil
case *TarBz2:
return NewTarBz2(), nil
case ... | go | {
"resource": ""
} |
q37403 | ByHeader | train | func ByHeader(input io.ReadSeeker) (Unarchiver, error) {
var matcher Matcher
for _, m := range matchers {
ok, err := m.Match(input)
if err != nil {
return nil, fmt.Errorf("matching on format %s: %v", m, err)
}
if ok {
matcher = m
break
}
}
switch matcher.(type) {
case *Zip:
return NewZip(), ni... | go | {
"resource": ""
} |
q37404 | CompressFile | train | func (fc FileCompressor) CompressFile(source, destination string) error {
if err := fc.CheckExt(destination); err != nil {
return err
}
if fc.Compressor == nil {
return fmt.Errorf("no compressor specified")
}
if !fc.OverwriteExisting && fileExists(destination) {
return fmt.Errorf("file exists: %s", destinati... | go | {
"resource": ""
} |
q37405 | DecompressFile | train | func (fc FileCompressor) DecompressFile(source, destination string) error {
if fc.Decompressor == nil {
return fmt.Errorf("no decompressor specified")
}
if !fc.OverwriteExisting && fileExists(destination) {
return fmt.Errorf("file exists: %s", destination)
}
in, err := os.Open(source)
if err != nil {
retur... | go | {
"resource": ""
} |
q37406 | FindBox | train | func (c *Config) FindBox(boxName string) (*Box, error) {
return findBox(boxName, c.LocateOrder)
} | go | {
"resource": ""
} |
q37407 | MustFindBox | train | func (c *Config) MustFindBox(boxName string) *Box {
box, err := findBox(boxName, c.LocateOrder)
if err != nil {
panic(err)
}
return box
} | go | {
"resource": ""
} |
q37408 | Link | train | func (e *EmbeddedBox) Link() {
for _, ed := range e.Dirs {
ed.ChildDirs = make([]*EmbeddedDir, 0)
ed.ChildFiles = make([]*EmbeddedFile, 0)
}
for path, ed := range e.Dirs {
// skip for root, it'll create a recursion
if path == "" {
continue
}
parentDirpath, _ := filepath.Split(path)
if strings.HasSuf... | go | {
"resource": ""
} |
q37409 | RegisterEmbeddedBox | train | func RegisterEmbeddedBox(name string, box *EmbeddedBox) {
if _, exists := EmbeddedBoxes[name]; exists {
panic(fmt.Sprintf("EmbeddedBox with name `%s` exists already", name))
}
EmbeddedBoxes[name] = box
} | go | {
"resource": ""
} |
q37410 | MustFindBox | train | func MustFindBox(name string) *Box {
box, err := findBox(name, defaultLocateOrder)
if err != nil {
panic(err)
}
return box
} | go | {
"resource": ""
} |
q37411 | String | train | func (b *Box) String(name string) (string, error) {
// check if box is embedded, optimized fast path
if b.IsEmbedded() {
// find file in embed
ef := b.embed.Files[name]
if ef == nil {
return "", os.ErrNotExist
}
// return as string
return ef.Content, nil
}
bts, err := b.Bytes(name)
if err != nil {
... | go | {
"resource": ""
} |
q37412 | MustString | train | func (b *Box) MustString(name string) string {
str, err := b.String(name)
if err != nil {
panic(err)
}
return str
} | go | {
"resource": ""
} |
q37413 | newVirtualFile | train | func newVirtualFile(ef *embedded.EmbeddedFile) *virtualFile {
vf := &virtualFile{
EmbeddedFile: ef,
offset: 0,
closed: false,
}
return vf
} | go | {
"resource": ""
} |
q37414 | newVirtualDir | train | func newVirtualDir(ed *embedded.EmbeddedDir) *virtualDir {
vd := &virtualDir{
EmbeddedDir: ed,
offset: 0,
closed: false,
}
return vd
} | go | {
"resource": ""
} |
q37415 | generated | train | func generated(filename string) bool {
return filepath.Base(filename) == boxFilename ||
strings.HasSuffix(filename, "."+boxFilename) ||
strings.HasSuffix(filename, sysoBoxSuffix)
} | go | {
"resource": ""
} |
q37416 | randomString | train | func randomString(length int) string {
rand.Seed(time.Now().UnixNano())
k := make([]rune, length)
for i := 0; i < length; i++ {
c := rand.Intn(35)
if c < 10 {
c += 48 // numbers (0-9) (0+48 == 48 == '0', 9+48 == 57 == '9')
} else {
c += 87 // lower case alphabets (a-z) (10+87 == 97 == 'a', 35+87 == 122 =... | go | {
"resource": ""
} |
q37417 | NewRatelimiter | train | func NewRatelimiter() *RateLimiter {
return &RateLimiter{
buckets: make(map[string]*Bucket),
global: new(int64),
customRateLimits: []*customRateLimit{
&customRateLimit{
suffix: "//reactions//",
requests: 1,
reset: 200 * time.Millisecond,
},
},
}
} | go | {
"resource": ""
} |
q37418 | GetBucket | train | func (r *RateLimiter) GetBucket(key string) *Bucket {
r.Lock()
defer r.Unlock()
if bucket, ok := r.buckets[key]; ok {
return bucket
}
b := &Bucket{
Remaining: 1,
Key: key,
global: r.global,
}
// Check if there is a custom ratelimit set for this bucket ID.
for _, rl := range r.customRateLimit... | go | {
"resource": ""
} |
q37419 | GetWaitTime | train | func (r *RateLimiter) GetWaitTime(b *Bucket, minRemaining int) time.Duration {
// If we ran out of calls and the reset time is still ahead of us
// then we need to take it easy and relax a little
if b.Remaining < minRemaining && b.reset.After(time.Now()) {
return b.reset.Sub(time.Now())
}
// Check for global ra... | go | {
"resource": ""
} |
q37420 | LockBucket | train | func (r *RateLimiter) LockBucket(bucketID string) *Bucket {
return r.LockBucketObject(r.GetBucket(bucketID))
} | go | {
"resource": ""
} |
q37421 | LockBucketObject | train | func (r *RateLimiter) LockBucketObject(b *Bucket) *Bucket {
b.Lock()
if wait := r.GetWaitTime(b, 1); wait > 0 {
time.Sleep(wait)
}
b.Remaining--
return b
} | go | {
"resource": ""
} |
q37422 | Release | train | func (b *Bucket) Release(headers http.Header) error {
defer b.Unlock()
// Check if the bucket uses a custom ratelimiter
if rl := b.customRateLimit; rl != nil {
if time.Now().Sub(b.lastReset) >= rl.reset {
b.Remaining = rl.requests - 1
b.lastReset = time.Now()
}
if b.Remaining < 1 {
b.reset = time.Now... | go | {
"resource": ""
} |
q37423 | NewState | train | func NewState() *State {
return &State{
Ready: Ready{
PrivateChannels: []*Channel{},
Guilds: []*Guild{},
},
TrackChannels: true,
TrackEmojis: true,
TrackMembers: true,
TrackRoles: true,
TrackVoice: true,
TrackPresences: true,
guildMap: make(map[string]*Guild),
cha... | go | {
"resource": ""
} |
q37424 | GuildAdd | train | func (s *State) GuildAdd(guild *Guild) error {
if s == nil {
return ErrNilState
}
s.Lock()
defer s.Unlock()
// Update the channels to point to the right guild, adding them to the channelMap as we go
for _, c := range guild.Channels {
s.channelMap[c.ID] = c
}
// If this guild contains a new member slice, ... | go | {
"resource": ""
} |
q37425 | GuildRemove | train | func (s *State) GuildRemove(guild *Guild) error {
if s == nil {
return ErrNilState
}
_, err := s.Guild(guild.ID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
delete(s.guildMap, guild.ID)
for i, g := range s.Guilds {
if g.ID == guild.ID {
s.Guilds = append(s.Guilds[:i], s.Guilds[i+1:]...)... | go | {
"resource": ""
} |
q37426 | Guild | train | func (s *State) Guild(guildID string) (*Guild, error) {
if s == nil {
return nil, ErrNilState
}
s.RLock()
defer s.RUnlock()
if g, ok := s.guildMap[guildID]; ok {
return g, nil
}
return nil, ErrStateNotFound
} | go | {
"resource": ""
} |
q37427 | PresenceAdd | train | func (s *State) PresenceAdd(guildID string, presence *Presence) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, p := range guild.Presences {
if p.User.ID == presence.User.ID {
//guild.Presences[i] = presence
... | go | {
"resource": ""
} |
q37428 | PresenceRemove | train | func (s *State) PresenceRemove(guildID string, presence *Presence) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, p := range guild.Presences {
if p.User.ID == presence.User.ID {
guild.Presences = append(guild.Pr... | go | {
"resource": ""
} |
q37429 | Presence | train | func (s *State) Presence(guildID, userID string) (*Presence, error) {
if s == nil {
return nil, ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return nil, err
}
for _, p := range guild.Presences {
if p.User.ID == userID {
return p, nil
}
}
return nil, ErrStateNotFound
} | go | {
"resource": ""
} |
q37430 | MemberRemove | train | func (s *State) MemberRemove(member *Member) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(member.GuildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
members, ok := s.memberMap[member.GuildID]
if !ok {
return ErrStateNotFound
}
_, ok = members[member.User.ID]
if !ok ... | go | {
"resource": ""
} |
q37431 | Member | train | func (s *State) Member(guildID, userID string) (*Member, error) {
if s == nil {
return nil, ErrNilState
}
s.RLock()
defer s.RUnlock()
members, ok := s.memberMap[guildID]
if !ok {
return nil, ErrStateNotFound
}
m, ok := members[userID]
if ok {
return m, nil
}
return nil, ErrStateNotFound
} | go | {
"resource": ""
} |
q37432 | RoleAdd | train | func (s *State) RoleAdd(guildID string, role *Role) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, r := range guild.Roles {
if r.ID == role.ID {
guild.Roles[i] = role
return nil
}
}
guild.Roles = append(... | go | {
"resource": ""
} |
q37433 | RoleRemove | train | func (s *State) RoleRemove(guildID, roleID string) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, r := range guild.Roles {
if r.ID == roleID {
guild.Roles = append(guild.Roles[:i], guild.Roles[i+1:]...)
retur... | go | {
"resource": ""
} |
q37434 | Role | train | func (s *State) Role(guildID, roleID string) (*Role, error) {
if s == nil {
return nil, ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return nil, err
}
s.RLock()
defer s.RUnlock()
for _, r := range guild.Roles {
if r.ID == roleID {
return r, nil
}
}
return nil, ErrStateNotFound
} | go | {
"resource": ""
} |
q37435 | ChannelAdd | train | func (s *State) ChannelAdd(channel *Channel) error {
if s == nil {
return ErrNilState
}
s.Lock()
defer s.Unlock()
// If the channel exists, replace it
if c, ok := s.channelMap[channel.ID]; ok {
if channel.Messages == nil {
channel.Messages = c.Messages
}
if channel.PermissionOverwrites == nil {
ch... | go | {
"resource": ""
} |
q37436 | ChannelRemove | train | func (s *State) ChannelRemove(channel *Channel) error {
if s == nil {
return ErrNilState
}
_, err := s.Channel(channel.ID)
if err != nil {
return err
}
if channel.Type == ChannelTypeDM || channel.Type == ChannelTypeGroupDM {
s.Lock()
defer s.Unlock()
for i, c := range s.PrivateChannels {
if c.ID =... | go | {
"resource": ""
} |
q37437 | Channel | train | func (s *State) Channel(channelID string) (*Channel, error) {
if s == nil {
return nil, ErrNilState
}
s.RLock()
defer s.RUnlock()
if c, ok := s.channelMap[channelID]; ok {
return c, nil
}
return nil, ErrStateNotFound
} | go | {
"resource": ""
} |
q37438 | Emoji | train | func (s *State) Emoji(guildID, emojiID string) (*Emoji, error) {
if s == nil {
return nil, ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return nil, err
}
s.RLock()
defer s.RUnlock()
for _, e := range guild.Emojis {
if e.ID == emojiID {
return e, nil
}
}
return nil, ErrStateNotFo... | go | {
"resource": ""
} |
q37439 | EmojiAdd | train | func (s *State) EmojiAdd(guildID string, emoji *Emoji) error {
if s == nil {
return ErrNilState
}
guild, err := s.Guild(guildID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, e := range guild.Emojis {
if e.ID == emoji.ID {
guild.Emojis[i] = emoji
return nil
}
}
guild.Emojis =... | go | {
"resource": ""
} |
q37440 | EmojisAdd | train | func (s *State) EmojisAdd(guildID string, emojis []*Emoji) error {
for _, e := range emojis {
if err := s.EmojiAdd(guildID, e); err != nil {
return err
}
}
return nil
} | go | {
"resource": ""
} |
q37441 | MessageAdd | train | func (s *State) MessageAdd(message *Message) error {
if s == nil {
return ErrNilState
}
c, err := s.Channel(message.ChannelID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
// If the message exists, merge in the new message contents.
for _, m := range c.Messages {
if m.ID == message.ID {
i... | go | {
"resource": ""
} |
q37442 | MessageRemove | train | func (s *State) MessageRemove(message *Message) error {
if s == nil {
return ErrNilState
}
return s.messageRemoveByID(message.ChannelID, message.ID)
} | go | {
"resource": ""
} |
q37443 | messageRemoveByID | train | func (s *State) messageRemoveByID(channelID, messageID string) error {
c, err := s.Channel(channelID)
if err != nil {
return err
}
s.Lock()
defer s.Unlock()
for i, m := range c.Messages {
if m.ID == messageID {
c.Messages = append(c.Messages[:i], c.Messages[i+1:]...)
return nil
}
}
return ErrStat... | go | {
"resource": ""
} |
q37444 | Message | train | func (s *State) Message(channelID, messageID string) (*Message, error) {
if s == nil {
return nil, ErrNilState
}
c, err := s.Channel(channelID)
if err != nil {
return nil, err
}
s.RLock()
defer s.RUnlock()
for _, m := range c.Messages {
if m.ID == messageID {
return m, nil
}
}
return nil, ErrSt... | go | {
"resource": ""
} |
q37445 | onReady | train | func (s *State) onReady(se *Session, r *Ready) (err error) {
if s == nil {
return ErrNilState
}
s.Lock()
defer s.Unlock()
// We must track at least the current user for Voice, even
// if state is disabled, store the bare essentials.
if !se.StateEnabled {
ready := Ready{
Version: r.Version,
SessionI... | go | {
"resource": ""
} |
q37446 | UserColor | train | func (s *State) UserColor(userID, channelID string) int {
if s == nil {
return 0
}
channel, err := s.Channel(channelID)
if err != nil {
return 0
}
guild, err := s.Guild(channel.GuildID)
if err != nil {
return 0
}
member, err := s.Member(guild.ID, userID)
if err != nil {
return 0
}
roles := Roles... | go | {
"resource": ""
} |
q37447 | ChangeChannel | train | func (v *VoiceConnection) ChangeChannel(channelID string, mute, deaf bool) (err error) {
v.log(LogInformational, "called")
data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, &channelID, mute, deaf}}
v.wsMutex.Lock()
err = v.session.wsConn.WriteJSON(data)
v.wsMutex.Unlock()
if err != nil {
return
... | go | {
"resource": ""
} |
q37448 | Disconnect | train | func (v *VoiceConnection) Disconnect() (err error) {
// Send a OP4 with a nil channel to disconnect
if v.sessionID != "" {
data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
v.session.wsMutex.Lock()
err = v.session.wsConn.WriteJSON(data)
v.session.wsMutex.Unlock()
v.sessionID ... | go | {
"resource": ""
} |
q37449 | Close | train | func (v *VoiceConnection) Close() {
v.log(LogInformational, "called")
v.Lock()
defer v.Unlock()
v.Ready = false
v.speaking = false
if v.close != nil {
v.log(LogInformational, "closing v.close")
close(v.close)
v.close = nil
}
if v.udpConn != nil {
v.log(LogInformational, "closing udp")
err := v.ud... | go | {
"resource": ""
} |
q37450 | AddHandler | train | func (v *VoiceConnection) AddHandler(h VoiceSpeakingUpdateHandler) {
v.Lock()
defer v.Unlock()
v.voiceSpeakingUpdateHandlers = append(v.voiceSpeakingUpdateHandlers, h)
} | go | {
"resource": ""
} |
q37451 | waitUntilConnected | train | func (v *VoiceConnection) waitUntilConnected() error {
v.log(LogInformational, "called")
i := 0
for {
v.RLock()
ready := v.Ready
v.RUnlock()
if ready {
return nil
}
if i > 10 {
return fmt.Errorf("timeout waiting for voice")
}
time.Sleep(1 * time.Second)
i++
}
} | go | {
"resource": ""
} |
q37452 | open | train | func (v *VoiceConnection) open() (err error) {
v.log(LogInformational, "called")
v.Lock()
defer v.Unlock()
// Don't open a websocket if one is already open
if v.wsConn != nil {
v.log(LogWarning, "refusing to overwrite non-nil websocket")
return
}
// TODO temp? loop to wait for the SessionID
i := 0
for ... | go | {
"resource": ""
} |
q37453 | wsListen | train | func (v *VoiceConnection) wsListen(wsConn *websocket.Conn, close <-chan struct{}) {
v.log(LogInformational, "called")
for {
_, message, err := v.wsConn.ReadMessage()
if err != nil {
// Detect if we have been closed manually. If a Close() has already
// happened, the websocket we are listening on will be d... | go | {
"resource": ""
} |
q37454 | udpOpen | train | func (v *VoiceConnection) udpOpen() (err error) {
v.Lock()
defer v.Unlock()
if v.wsConn == nil {
return fmt.Errorf("nil voice websocket")
}
if v.udpConn != nil {
return fmt.Errorf("udp connection already open")
}
if v.close == nil {
return fmt.Errorf("nil close channel")
}
if v.endpoint == "" {
re... | go | {
"resource": ""
} |
q37455 | udpKeepAlive | train | func (v *VoiceConnection) udpKeepAlive(udpConn *net.UDPConn, close <-chan struct{}, i time.Duration) {
if udpConn == nil || close == nil {
return
}
var err error
var sequence uint64
packet := make([]byte, 8)
ticker := time.NewTicker(i)
defer ticker.Stop()
for {
binary.LittleEndian.PutUint64(packet, seq... | go | {
"resource": ""
} |
q37456 | opusSender | train | func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}, opus <-chan []byte, rate, size int) {
if udpConn == nil || close == nil {
return
}
// VoiceConnection is now ready to receive audio packets
// TODO: this needs reviewed as I think there must be a better way.
v.Lock()
v.Ready = t... | go | {
"resource": ""
} |
q37457 | MessageFormat | train | func (e *Emoji) MessageFormat() string {
if e.ID != "" && e.Name != "" {
if e.Animated {
return "<a:" + e.APIName() + ">"
}
return "<:" + e.APIName() + ">"
}
return e.APIName()
} | go | {
"resource": ""
} |
q37458 | APIName | train | func (e *Emoji) APIName() string {
if e.ID != "" && e.Name != "" {
return e.Name + ":" + e.ID
}
if e.Name != "" {
return e.Name
}
return e.ID
} | go | {
"resource": ""
} |
q37459 | UnmarshalJSON | train | func (t *TimeStamps) UnmarshalJSON(b []byte) error {
temp := struct {
End float64 `json:"end,omitempty"`
Start float64 `json:"start,omitempty"`
}{}
err := json.Unmarshal(b, &temp)
if err != nil {
return err
}
t.EndTimestamp = int64(temp.End)
t.StartTimestamp = int64(temp.Start)
return nil
} | go | {
"resource": ""
} |
q37460 | Request | train | func (s *Session) Request(method, urlStr string, data interface{}) (response []byte, err error) {
return s.RequestWithBucketID(method, urlStr, data, strings.SplitN(urlStr, "?", 2)[0])
} | go | {
"resource": ""
} |
q37461 | RequestWithLockedBucket | train | func (s *Session) RequestWithLockedBucket(method, urlStr, contentType string, b []byte, bucket *Bucket, sequence int) (response []byte, err error) {
if s.Debug {
log.Printf("API REQUEST %8s :: %s\n", method, urlStr)
log.Printf("API REQUEST PAYLOAD :: [%s]\n", string(b))
}
req, err := http.NewRequest(method, ur... | go | {
"resource": ""
} |
q37462 | Register | train | func (s *Session) Register(username string) (token string, err error) {
data := struct {
Username string `json:"username"`
}{username}
response, err := s.RequestWithBucketID("POST", EndpointRegister, data, EndpointRegister)
if err != nil {
return
}
temp := struct {
Token string `json:"token"`
}{}
err ... | go | {
"resource": ""
} |
q37463 | Logout | train | func (s *Session) Logout() (err error) {
// _, err = s.Request("POST", LOGOUT, `{"token": "` + s.Token + `"}`)
if s.Token == "" {
return
}
data := struct {
Token string `json:"token"`
}{s.Token}
_, err = s.RequestWithBucketID("POST", EndpointLogout, data, EndpointLogout)
return
} | go | {
"resource": ""
} |
q37464 | UserUpdate | train | func (s *Session) UserUpdate(email, password, username, avatar, newPassword string) (st *User, err error) {
// NOTE: Avatar must be either the hash/id of existing Avatar or
// data:image/png;base64,BASE64_STRING_OF_NEW_AVATAR_PNG
// to set a new avatar.
// If left blank, avatar will be set to null/blank
data := ... | go | {
"resource": ""
} |
q37465 | UserSettings | train | func (s *Session) UserSettings() (st *Settings, err error) {
body, err := s.RequestWithBucketID("GET", EndpointUserSettings("@me"), nil, EndpointUserSettings(""))
if err != nil {
return
}
err = unmarshal(body, &st)
return
} | go | {
"resource": ""
} |
q37466 | UserConnections | train | func (s *Session) UserConnections() (conn []*UserConnection, err error) {
response, err := s.RequestWithBucketID("GET", EndpointUserConnections("@me"), nil, EndpointUserConnections("@me"))
if err != nil {
return nil, err
}
err = unmarshal(response, &conn)
if err != nil {
return
}
return
} | go | {
"resource": ""
} |
q37467 | UserChannels | train | func (s *Session) UserChannels() (st []*Channel, err error) {
body, err := s.RequestWithBucketID("GET", EndpointUserChannels("@me"), nil, EndpointUserChannels(""))
if err != nil {
return
}
err = unmarshal(body, &st)
return
} | go | {
"resource": ""
} |
q37468 | ChannelMessageEditComplex | train | func (s *Session) ChannelMessageEditComplex(m *MessageEdit) (st *Message, err error) {
if m.Embed != nil && m.Embed.Type == "" {
m.Embed.Type = "rich"
}
response, err := s.RequestWithBucketID("PATCH", EndpointChannelMessage(m.Channel, m.ID), m, EndpointChannelMessage(m.Channel, ""))
if err != nil {
return
}
... | go | {
"resource": ""
} |
q37469 | ChannelMessageDelete | train | func (s *Session) ChannelMessageDelete(channelID, messageID string) (err error) {
_, err = s.RequestWithBucketID("DELETE", EndpointChannelMessage(channelID, messageID), nil, EndpointChannelMessage(channelID, ""))
return
} | go | {
"resource": ""
} |
q37470 | VoiceICE | train | func (s *Session) VoiceICE() (st *VoiceICE, err error) {
body, err := s.RequestWithBucketID("GET", EndpointVoiceIce, nil, EndpointVoiceIce)
if err != nil {
return
}
err = unmarshal(body, &st)
return
} | go | {
"resource": ""
} |
q37471 | GatewayBot | train | func (s *Session) GatewayBot() (st *GatewayBotResponse, err error) {
response, err := s.RequestWithBucketID("GET", EndpointGatewayBot, nil, EndpointGatewayBot)
if err != nil {
return
}
err = unmarshal(response, &st)
if err != nil {
return
}
// Ensure the gateway always has a trailing slash.
// MacOS will... | go | {
"resource": ""
} |
q37472 | RelationshipsMutualGet | train | func (s *Session) RelationshipsMutualGet(userID string) (mf []*User, err error) {
body, err := s.RequestWithBucketID("GET", EndpointRelationshipsMutual(userID), nil, EndpointRelationshipsMutual(userID))
if err != nil {
return
}
err = unmarshal(body, &mf)
return
} | go | {
"resource": ""
} |
q37473 | Handle | train | func (eh channelCreateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*ChannelCreate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37474 | Handle | train | func (eh channelDeleteEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*ChannelDelete); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37475 | Handle | train | func (eh channelPinsUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*ChannelPinsUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37476 | Handle | train | func (eh channelUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*ChannelUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37477 | Handle | train | func (eh connectEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*Connect); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37478 | Handle | train | func (eh disconnectEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*Disconnect); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37479 | Handle | train | func (eh eventEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*Event); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37480 | Handle | train | func (eh guildBanAddEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildBanAdd); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37481 | Handle | train | func (eh guildBanRemoveEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildBanRemove); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37482 | Handle | train | func (eh guildCreateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildCreate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37483 | Handle | train | func (eh guildDeleteEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildDelete); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37484 | Handle | train | func (eh guildEmojisUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildEmojisUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37485 | Handle | train | func (eh guildIntegrationsUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildIntegrationsUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37486 | Handle | train | func (eh guildMemberAddEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildMemberAdd); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37487 | Handle | train | func (eh guildMemberRemoveEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildMemberRemove); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37488 | Handle | train | func (eh guildMemberUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildMemberUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37489 | Handle | train | func (eh guildMembersChunkEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildMembersChunk); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37490 | Handle | train | func (eh guildRoleCreateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildRoleCreate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37491 | Handle | train | func (eh guildRoleDeleteEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildRoleDelete); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37492 | Handle | train | func (eh guildRoleUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildRoleUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37493 | Handle | train | func (eh guildUpdateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*GuildUpdate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37494 | Handle | train | func (eh messageAckEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageAck); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37495 | Handle | train | func (eh messageCreateEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageCreate); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37496 | Handle | train | func (eh messageDeleteEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageDelete); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37497 | Handle | train | func (eh messageDeleteBulkEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageDeleteBulk); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37498 | Handle | train | func (eh messageReactionAddEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageReactionAdd); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
q37499 | Handle | train | func (eh messageReactionRemoveEventHandler) Handle(s *Session, i interface{}) {
if t, ok := i.(*MessageReactionRemove); ok {
eh(s, t)
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.