_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q172700 | Detect | validation | func Detect() (Distro, error) {
var id string
var err error
if _, err = os.Stat("/etc/os-release"); !os.IsNotExist(err) {
cfg, err := shconf.ParseFile("/etc/os-release")
if err != nil {
return 0, err
}
if id, err = cfg.Get("ID"); err != nil {
return 0, err
}
if v, found := idToDistro[id]; found {... | go | {
"resource": ""
} |
q172701 | AddSystem | validation | func (w *World) AddSystem(system System) {
if initializer, ok := system.(Initializer); ok {
initializer.New(w)
}
w.systems = append(w.systems, system)
sort.Sort(w.systems)
} | go | {
"resource": ""
} |
q172702 | AddSystemInterface | validation | func (w *World) AddSystemInterface(sys SystemAddByInterfacer, in interface{}, ex interface{}) {
w.AddSystem(sys)
if w.sysIn == nil {
w.sysIn = make(map[reflect.Type]reflect.Type)
}
w.sysIn[reflect.TypeOf(sys)] = reflect.TypeOf(in).Elem()
if ex == nil {
return
}
if w.sysEx == nil {
w.sysEx = make(map[re... | go | {
"resource": ""
} |
q172703 | AddEntity | validation | func (w *World) AddEntity(e Identifier) {
if w.sysIn == nil {
w.sysIn = make(map[reflect.Type]reflect.Type)
}
if w.sysEx == nil {
w.sysEx = make(map[reflect.Type]reflect.Type)
}
for _, system := range w.systems {
sys, ok := system.(SystemAddByInterfacer)
if !ok {
continue
}
if ex, not := w.sysEx[ref... | go | {
"resource": ""
} |
q172704 | Update | validation | func (w *World) Update(dt float32) {
for _, system := range w.Systems() {
system.Update(dt)
}
} | go | {
"resource": ""
} |
q172705 | RemoveEntity | validation | func (w *World) RemoveEntity(e BasicEntity) {
for _, sys := range w.systems {
sys.Remove(e)
}
} | go | {
"resource": ""
} |
q172706 | NewBasics | validation | func NewBasics(amount int) []BasicEntity {
entities := make([]BasicEntity, amount)
lastID := atomic.AddUint64(&idInc, uint64(amount))
for i := 0; i < amount; i++ {
entities[i].id = lastID - uint64(amount) + uint64(i) + 1
}
return entities
} | go | {
"resource": ""
} |
q172707 | AppendChild | validation | func (e *BasicEntity) AppendChild(child *BasicEntity) {
child.parent = e
e.children = append(e.children, *child)
} | go | {
"resource": ""
} |
q172708 | Less | validation | func (is IdentifierSlice) Less(i, j int) bool {
return is[i].ID() < is[j].ID()
} | go | {
"resource": ""
} |
q172709 | Swap | validation | func (is IdentifierSlice) Swap(i, j int) {
is[i], is[j] = is[j], is[i]
} | go | {
"resource": ""
} |
q172710 | NewGroup | validation | func NewGroup() *Group {
in := make(chan Message)
close := make(chan bool)
return &Group{in: in, close: close, clock: 0}
} | go | {
"resource": ""
} |
q172711 | Members | validation | func (g *Group) Members() []*Member {
g.memberLock.Lock()
res := g.members[:]
g.memberLock.Unlock()
return res
} | go | {
"resource": ""
} |
q172712 | Leave | validation | func (g *Group) Leave(leaving *Member) error {
g.memberLock.Lock()
memberIndex := -1
for index, member := range g.members {
if member == leaving {
memberIndex = index
break
}
}
if memberIndex == -1 {
g.memberLock.Unlock()
return errors.New("Could not find provided member for removal")
}
g.members =... | go | {
"resource": ""
} |
q172713 | Add | validation | func (g *Group) Add(memberChannel chan interface{}) *Member {
g.memberLock.Lock()
g.clockLock.Lock()
member := &Member{
group: g,
Read: memberChannel,
clock: g.clock,
messageQueue: PriorityQueue{},
send: make(chan Message),
close: make(chan bool),
}
go member.listen... | go | {
"resource": ""
} |
q172714 | Broadcast | validation | func (g *Group) Broadcast(timeout time.Duration) {
var timeoutChannel <-chan time.Time
if timeout != 0 {
timeoutChannel = time.After(timeout)
}
for {
select {
case received := <-g.in:
g.memberLock.Lock()
g.clockLock.Lock()
members := g.members[:]
received.clock = g.clock
g.clock++
g.clockLoc... | go | {
"resource": ""
} |
q172715 | Send | validation | func (g *Group) Send(val interface{}) {
g.in <- Message{sender: nil, payload: val}
} | go | {
"resource": ""
} |
q172716 | Send | validation | func (m *Member) Send(val interface{}) {
m.group.in <- Message{sender: m, payload: val}
} | go | {
"resource": ""
} |
q172717 | update | validation | func (pq *PriorityQueue) update(item *Item, value string, priority int) {
item.value = value
item.priority = priority
heap.Fix(pq, item.index)
} | go | {
"resource": ""
} |
q172718 | NewBot | validation | func NewBot(host, nick string, options ...func(*Bot)) (*Bot, error) {
// Defaults are set here
bot := Bot{
Incoming: make(chan *Message, 16),
outgoing: make(chan string, 16),
started: time.Now(),
unixastr: fmt.Sprintf("@%s-%s/bot", host, nick),
Host: host,
Nick: nick... | go | {
"resource": ""
} |
q172719 | Uptime | validation | func (bot *Bot) Uptime() string {
return fmt.Sprintf("Started: %s, Uptime: %s", bot.started, time.Since(bot.started))
} | go | {
"resource": ""
} |
q172720 | handleIncomingMessages | validation | func (bot *Bot) handleIncomingMessages() {
scan := bufio.NewScanner(bot.con)
for scan.Scan() {
// Disconnect if we have seen absolutely nothing for 300 seconds
bot.con.SetDeadline(time.Now().Add(bot.PingTimeout))
msg := ParseMessage(scan.Text())
bot.Debug("Incoming", "raw", scan.Text(), "msg.To", msg.To, "msg... | go | {
"resource": ""
} |
q172721 | handleOutgoingMessages | validation | func (bot *Bot) handleOutgoingMessages() {
for s := range bot.outgoing {
bot.Debug("Outgoing", "data", s)
_, err := fmt.Fprint(bot.con, s+"\r\n")
if err != nil {
bot.Error("handleOutgoingMessages fmt.Fprint error", "err", err)
return
}
time.Sleep(bot.ThrottleDelay)
}
} | go | {
"resource": ""
} |
q172722 | WaitFor | validation | func (bot *Bot) WaitFor(filter func(*Message) bool) {
for mes := range bot.Incoming {
if filter(mes) {
return
}
}
return
} | go | {
"resource": ""
} |
q172723 | StandardRegistration | validation | func (bot *Bot) StandardRegistration() {
//Server registration
if bot.Password != "" {
bot.Send("PASS " + bot.Password)
}
bot.Debug("Sending standard registration")
bot.sendUserCommand(bot.Nick, bot.Nick, "8")
bot.SetNick(bot.Nick)
} | go | {
"resource": ""
} |
q172724 | sendUserCommand | validation | func (bot *Bot) sendUserCommand(user, realname, mode string) {
bot.Send(fmt.Sprintf("USER %s %s * :%s", user, mode, realname))
} | go | {
"resource": ""
} |
q172725 | SetNick | validation | func (bot *Bot) SetNick(nick string) {
bot.Nick = nick
bot.Send(fmt.Sprintf("NICK %s", nick))
} | go | {
"resource": ""
} |
q172726 | Run | validation | func (bot *Bot) Run() {
bot.Debug("Starting bot goroutines")
// Attempt reconnection
var hijack bool
if bot.HijackSession {
if bot.SSL {
bot.Crit("Can't Hijack a SSL connection")
return
}
hijack = bot.hijackSession()
bot.Debug("Hijack", "Did we?", hijack)
}
if !hijack {
err := bot.connect(bot.Ho... | go | {
"resource": ""
} |
q172727 | ChMode | validation | func (bot *Bot) ChMode(user, channel, mode string) {
bot.Send("MODE " + channel + " " + mode + " " + user)
} | go | {
"resource": ""
} |
q172728 | Close | validation | func (bot *Bot) Close() error {
if bot.unixlist != nil {
return bot.unixlist.Close()
}
return nil
} | go | {
"resource": ""
} |
q172729 | AddTrigger | validation | func (bot *Bot) AddTrigger(h Handler) {
bot.handlers = append(bot.handlers, h)
} | go | {
"resource": ""
} |
q172730 | Handle | validation | func (t Trigger) Handle(b *Bot, m *Message) bool {
return t.Condition(b, m) && t.Action(b, m)
} | go | {
"resource": ""
} |
q172731 | StartUnixListener | validation | func (irc *Bot) StartUnixListener() {
unaddr, err := net.ResolveUnixAddr("unix", irc.unixastr)
if err != nil {
panic(err)
}
list, err := net.ListenUnix("unix", unaddr)
if err != nil {
panic(err)
}
irc.unixlist = list
con, err := list.AcceptUnix()
if err != nil {
fmt.Println("unix listener error: ", err)... | go | {
"resource": ""
} |
q172732 | hijackSession | validation | func (irc *Bot) hijackSession() bool {
unaddr, err := net.ResolveUnixAddr("unix", irc.unixastr) // The only way to get an error here is if the first parameter is not one of "unix", "unixgram" or "unixpacket". That will never happen.
if err != nil {
panic(err)
}
con, err := net.DialUnix("unix", nil, unaddr)
if er... | go | {
"resource": ""
} |
q172733 | Ended | validation | func (c *Call) Ended() bool {
// https://www.twilio.com/docs/api/rest/call#call-status-values
switch c.Status {
case StatusCompleted, StatusCanceled, StatusFailed, StatusBusy, StatusNoAnswer:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q172734 | EndedUnsuccessfully | validation | func (c *Call) EndedUnsuccessfully() bool {
// https://www.twilio.com/docs/api/rest/call#call-status-values
switch c.Status {
case StatusCanceled, StatusFailed, StatusBusy, StatusNoAnswer:
return true
default:
return false
}
} | go | {
"resource": ""
} |
q172735 | Cancel | validation | func (c *CallService) Cancel(sid string) (*Call, error) {
data := url.Values{}
data.Set("Status", string(StatusCanceled))
return c.Update(context.Background(), sid, data)
} | go | {
"resource": ""
} |
q172736 | Hangup | validation | func (c *CallService) Hangup(sid string) (*Call, error) {
data := url.Values{}
data.Set("Status", string(StatusCompleted))
return c.Update(context.Background(), sid, data)
} | go | {
"resource": ""
} |
q172737 | Redirect | validation | func (c *CallService) Redirect(sid string, u *url.URL) (*Call, error) {
data := url.Values{}
data.Set("Url", u.String())
return c.Update(context.Background(), sid, data)
} | go | {
"resource": ""
} |
q172738 | Create | validation | func (c *CallService) Create(ctx context.Context, data url.Values) (*Call, error) {
call := new(Call)
err := c.client.CreateResource(ctx, callsPathPart, data, call)
return call, err
} | go | {
"resource": ""
} |
q172739 | MakeCall | validation | func (c *CallService) MakeCall(from string, to string, u *url.URL) (*Call, error) {
data := url.Values{}
data.Set("From", from)
data.Set("To", to)
data.Set("Url", u.String())
return c.Create(context.Background(), data)
} | go | {
"resource": ""
} |
q172740 | GetCallsInRange | validation | func (c *CallService) GetCallsInRange(start time.Time, end time.Time, data url.Values) CallPageIterator {
if start.After(end) {
panic("start date is after end date")
}
d := url.Values{}
if data != nil {
for k, v := range data {
d[k] = v
}
}
d.Del("StartTime")
d.Del("Page") // just in case
if start != E... | go | {
"resource": ""
} |
q172741 | GetNextCallsInRange | validation | func (c *CallService) GetNextCallsInRange(start time.Time, end time.Time, nextPageURI string) CallPageIterator {
if nextPageURI == "" {
panic("nextpageuri is empty")
}
iter := NewNextPageIterator(c.client, callsPathPart)
iter.SetNextPageURI(types.NullString{Valid: true, String: nextPageURI})
return &callDateIter... | go | {
"resource": ""
} |
q172742 | GetRecordings | validation | func (c *CallService) GetRecordings(ctx context.Context, callSid string, data url.Values) (*RecordingPage, error) {
if data == nil {
data = url.Values{}
}
// Cheat - hit the Recordings list view with a filter instead of
// GET /calls/CA123/Recordings. The former is probably more reliable
data.Set("CallSid", call... | go | {
"resource": ""
} |
q172743 | GetRecordingsIterator | validation | func (c *CallService) GetRecordingsIterator(callSid string, data url.Values) *RecordingPageIterator {
if data == nil {
data = url.Values{}
}
// Cheat - hit the Recordings list view with a filter instead of
// GET /calls/CA123/Recordings. The former is probably more reliable
data.Set("CallSid", callSid)
return c... | go | {
"resource": ""
} |
q172744 | Get | validation | func (cvps *CountryVoicePriceService) Get(ctx context.Context, isoCountry string) (*VoicePrice, error) {
voicePrice := new(VoicePrice)
err := cvps.client.GetResource(ctx, voicePathPart+"/Countries", isoCountry, voicePrice)
return voicePrice, err
} | go | {
"resource": ""
} |
q172745 | Get | validation | func (nvps *NumberVoicePriceService) Get(ctx context.Context, number string) (*VoiceNumberPrice, error) {
voiceNumPrice := new(VoiceNumberPrice)
err := nvps.client.GetResource(ctx, voicePathPart+"/Numbers", number, voiceNumPrice)
return voiceNumPrice, err
} | go | {
"resource": ""
} |
q172746 | GetPage | validation | func (cvps *CountryVoicePriceService) GetPage(ctx context.Context, data url.Values) (*CountriesPricePage, error) {
return cvps.GetPageIterator(data).Next(ctx)
} | go | {
"resource": ""
} |
q172747 | Get | validation | func (cmps *CountryMessagingPriceService) Get(ctx context.Context, isoCountry string) (*MessagePrice, error) {
messagePrice := new(MessagePrice)
err := cmps.client.GetResource(ctx, messagingPathPart+"/Countries", isoCountry, messagePrice)
return messagePrice, err
} | go | {
"resource": ""
} |
q172748 | GetPage | validation | func (cmps *CountryMessagingPriceService) GetPage(ctx context.Context, data url.Values) (*CountriesPricePage, error) {
return cmps.GetPageIterator(data).Next(ctx)
} | go | {
"resource": ""
} |
q172749 | Delete | validation | func (r *KeyService) Delete(ctx context.Context, sid string) error {
return r.client.DeleteResource(ctx, keyPathPart, sid)
} | go | {
"resource": ""
} |
q172750 | GetAlertsInRange | validation | func (a *AlertService) GetAlertsInRange(start time.Time, end time.Time, data url.Values) AlertPageIterator {
if start.After(end) {
panic("start date is after end date")
}
d := url.Values{}
if data != nil {
for k, v := range data {
d[k] = v
}
}
d.Del("Page") // just in case
if start != Epoch {
startFor... | go | {
"resource": ""
} |
q172751 | GetNextAlertsInRange | validation | func (a *AlertService) GetNextAlertsInRange(start time.Time, end time.Time, nextPageURI string) AlertPageIterator {
if nextPageURI == "" {
panic("nextpageuri is empty")
}
iter := NewNextPageIterator(a.client, callsPathPart)
iter.SetNextPageURI(types.NullString{Valid: true, String: nextPageURI})
return &alertDate... | go | {
"resource": ""
} |
q172752 | Description | validation | func (a *Alert) Description() string {
return capitalize(strings.TrimSpace(strings.TrimSuffix(a.description(), ".")))
} | go | {
"resource": ""
} |
q172753 | StatusCode | validation | func (a *Alert) StatusCode() int {
vals, err := url.ParseQuery(a.AlertText)
if err != nil {
return 0
}
if code := vals.Get("httpResponse"); code != "" {
i, err := strconv.ParseInt(code, 10, 64)
if err == nil && i > 99 && i < 600 {
return int(i)
}
}
return 0
} | go | {
"resource": ""
} |
q172754 | Friendly | validation | func (d Direction) Friendly() string {
switch d {
case DirectionOutboundReply:
return "Reply"
case DirectionOutboundCall:
return "Outgoing (from call)"
case DirectionOutboundAPI:
return "Outgoing (from API)"
case DirectionInbound:
return "Incoming"
case DirectionOutboundDial:
return "Outgoing (via Dial)... | go | {
"resource": ""
} |
q172755 | SendMessage | validation | func (m *MessageService) SendMessage(from string, to string, body string, mediaURLs []*url.URL) (*Message, error) {
v := url.Values{
"Body": []string{body},
"From": []string{from},
"To": []string{to},
}
if mediaURLs != nil {
for _, mediaURL := range mediaURLs {
v.Add("MediaUrl", mediaURL.String())
}
... | go | {
"resource": ""
} |
q172756 | GetPage | validation | func (m *MessageService) GetPage(ctx context.Context, data url.Values) (*MessagePage, error) {
iter := m.GetPageIterator(data)
return iter.Next(ctx)
} | go | {
"resource": ""
} |
q172757 | GetMessagesInRange | validation | func (c *MessageService) GetMessagesInRange(start time.Time, end time.Time, data url.Values) MessagePageIterator {
if start.After(end) {
panic("start date is after end date")
}
d := url.Values{}
if data != nil {
for k, v := range data {
d[k] = v
}
}
d.Del("DateSent")
d.Del("Page") // just in case
// Om... | go | {
"resource": ""
} |
q172758 | GetNextMessagesInRange | validation | func (c *MessageService) GetNextMessagesInRange(start time.Time, end time.Time, nextPageURI string) MessagePageIterator {
if nextPageURI == "" {
panic("nextpageuri is empty")
}
iter := NewNextPageIterator(c.client, messagesPathPart)
iter.SetNextPageURI(types.NullString{Valid: true, String: nextPageURI})
return &... | go | {
"resource": ""
} |
q172759 | Get | validation | func (c *QueueService) Get(ctx context.Context, sid string) (*Queue, error) {
queue := new(Queue)
err := c.client.GetResource(ctx, queuePathPart, sid, queue)
return queue, err
} | go | {
"resource": ""
} |
q172760 | Create | validation | func (c *QueueService) Create(ctx context.Context, data url.Values) (*Queue, error) {
queue := new(Queue)
err := c.client.CreateResource(ctx, queuePathPart, data, queue)
return queue, err
} | go | {
"resource": ""
} |
q172761 | Delete | validation | func (c *QueueService) Delete(ctx context.Context, sid string) error {
return c.client.DeleteResource(ctx, queuePathPart, sid)
} | go | {
"resource": ""
} |
q172762 | GetConferencesInRange | validation | func (c *ConferenceService) GetConferencesInRange(start time.Time, end time.Time, data url.Values) ConferencePageIterator {
if start.After(end) {
panic("start date is after end date")
}
d := url.Values{}
if data != nil {
for k, v := range data {
d[k] = v
}
}
d.Del("DateCreated")
d.Del("Page") // just in... | go | {
"resource": ""
} |
q172763 | GetNextConferencesInRange | validation | func (c *ConferenceService) GetNextConferencesInRange(start time.Time, end time.Time, nextPageURI string) ConferencePageIterator {
if nextPageURI == "" {
panic("nextpageuri is empty")
}
iter := NewNextPageIterator(c.client, conferencePathPart)
iter.SetNextPageURI(types.NullString{Valid: true, String: nextPageURI}... | go | {
"resource": ""
} |
q172764 | NewPhoneNumber | validation | func NewPhoneNumber(pn string) (PhoneNumber, error) {
if len(pn) == 0 {
return "", ErrEmptyNumber
}
num, err := libphonenumber.Parse(pn, "US")
// Add some better error messages - the ones in libphonenumber are generic
switch {
case err == libphonenumber.ErrNotANumber:
return "", fmt.Errorf("twilio: Invalid ph... | go | {
"resource": ""
} |
q172765 | Friendly | validation | func (pn PhoneNumber) Friendly() string {
num, err := libphonenumber.Parse(string(pn), "US")
if err != nil {
return string(pn)
}
return libphonenumber.Format(num, libphonenumber.INTERNATIONAL)
} | go | {
"resource": ""
} |
q172766 | NewTwilioTime | validation | func NewTwilioTime(val string) *TwilioTime {
t, err := time.Parse(TimeLayout, val)
if err == nil {
return &TwilioTime{Time: t, Valid: true}
} else {
return &TwilioTime{}
}
} | go | {
"resource": ""
} |
q172767 | price | validation | func price(unit string, amount string) string {
if len(amount) == 0 {
return amount
}
if amount[0] == '-' {
amount = amount[1:]
} else {
amount = "-" + amount
}
for strings.Contains(amount, ".") && strings.HasSuffix(amount, "0") {
amount = amount[:len(amount)-1]
}
if strings.HasSuffix(amount, ".") {
a... | go | {
"resource": ""
} |
q172768 | capitalize | validation | func capitalize(s string) string {
r, l := utf8.DecodeRuneInString(s)
b := make([]byte, l)
utf8.EncodeRune(b, unicode.ToTitle(r))
return strings.Join([]string{string(b), s[l:]}, "")
} | go | {
"resource": ""
} |
q172769 | Delete | validation | func (o *OutgoingCallerIDService) Delete(ctx context.Context, sid string) error {
return o.client.DeleteResource(ctx, callerIDPathPart, sid)
} | go | {
"resource": ""
} |
q172770 | NewPricingClient | validation | func NewPricingClient(accountSid string, authToken string, httpClient *http.Client) *Client {
if httpClient == nil {
httpClient = &http.Client{Timeout: defaultTimeout}
}
restClient := rest.NewClient(accountSid, authToken, PricingBaseURL)
c := &Client{Client: restClient, AccountSid: accountSid, AuthToken: authToke... | go | {
"resource": ""
} |
q172771 | NewClient | validation | func NewClient(accountSid string, authToken string, httpClient *http.Client) *Client {
if httpClient == nil {
httpClient = &http.Client{Timeout: defaultTimeout}
}
restClient := rest.NewClient(accountSid, authToken, BaseURL)
restClient.Client = httpClient
restClient.UploadType = rest.FormURLEncoded
restClient.E... | go | {
"resource": ""
} |
q172772 | CreateResource | validation | func (c *Client) CreateResource(ctx context.Context, pathPart string, data url.Values, v interface{}) error {
return c.MakeRequest(ctx, "POST", pathPart, data, v)
} | go | {
"resource": ""
} |
q172773 | MakeRequest | validation | func (c *Client) MakeRequest(ctx context.Context, method string, pathPart string, data url.Values, v interface{}) error {
if !strings.HasPrefix(pathPart, "/"+c.APIVersion) {
pathPart = c.FullPath(pathPart)
}
rb := new(strings.Reader)
if data != nil && (method == "POST" || method == "PUT") {
rb = strings.NewRead... | go | {
"resource": ""
} |
q172774 | Delete | validation | func (r *ApplicationService) Delete(ctx context.Context, sid string) error {
return r.client.DeleteResource(ctx, applicationPathPart, sid)
} | go | {
"resource": ""
} |
q172775 | URL | validation | func (r *Recording) URL(extension string) string {
if !strings.HasPrefix(extension, ".") {
extension = "." + extension
}
return strings.Join([]string{BaseURL, r.APIVersion, "Accounts", r.AccountSid, recordingsPathPart, r.Sid + extension}, "/")
} | go | {
"resource": ""
} |
q172776 | Delete | validation | func (r *RecordingService) Delete(ctx context.Context, sid string) error {
return r.client.DeleteResource(ctx, recordingsPathPart, sid)
} | go | {
"resource": ""
} |
q172777 | Get | validation | func (m *MediaService) Get(ctx context.Context, messageSid string, sid string) (*Media, error) {
me := new(Media)
err := m.client.GetResource(ctx, mediaPathPart(messageSid), sid, me)
return me, err
} | go | {
"resource": ""
} |
q172778 | BuyNumber | validation | func (ipn *IncomingNumberService) BuyNumber(phoneNumber string) (*IncomingPhoneNumber, error) {
data := url.Values{"PhoneNumber": []string{phoneNumber}}
return ipn.NumberPurchasingService.Create(context.Background(), data)
} | go | {
"resource": ""
} |
q172779 | Get | validation | func (ipn *IncomingNumberService) Get(ctx context.Context, sid string) (*IncomingPhoneNumber, error) {
number := new(IncomingPhoneNumber)
err := ipn.client.GetResource(ctx, numbersPathPart, sid, number)
return number, err
} | go | {
"resource": ""
} |
q172780 | Release | validation | func (ipn *IncomingNumberService) Release(ctx context.Context, sid string) error {
return ipn.client.DeleteResource(ctx, numbersPathPart, sid)
} | go | {
"resource": ""
} |
q172781 | GetPage | validation | func (ins *IncomingNumberService) GetPage(ctx context.Context, data url.Values) (*IncomingPhoneNumberPage, error) {
iter := ins.GetPageIterator(data)
return iter.Next(ctx)
} | go | {
"resource": ""
} |
q172782 | Get | validation | func (c *TranscriptionService) Get(ctx context.Context, sid string) (*Transcription, error) {
transcription := new(Transcription)
err := c.client.GetResource(ctx, transcriptionPathPart, sid, transcription)
return transcription, err
} | go | {
"resource": ""
} |
q172783 | Delete | validation | func (c *TranscriptionService) Delete(ctx context.Context, sid string) error {
return c.client.DeleteResource(ctx, transcriptionPathPart, sid)
} | go | {
"resource": ""
} |
q172784 | Get | validation | func (cpnps *CountryPhoneNumberPriceService) Get(ctx context.Context, isoCountry string) (*NumberPrice, error) {
numberPrice := new(NumberPrice)
err := cpnps.client.GetResource(ctx, phoneNumbersPathPart+"/Countries", isoCountry, numberPrice)
return numberPrice, err
} | go | {
"resource": ""
} |
q172785 | GetPage | validation | func (cpnps *CountryPhoneNumberPriceService) GetPage(ctx context.Context, data url.Values) (*CountriesPricePage, error) {
return cpnps.GetPageIterator(data).Next(ctx)
} | go | {
"resource": ""
} |
q172786 | Next | validation | func (p *PageIterator) Next(ctx context.Context, v interface{}) error {
var err error
switch {
case p.nextPageURI.Valid:
err = p.client.GetNextPage(ctx, p.nextPageURI.String, v)
case p.count == 0:
err = p.client.ListResource(ctx, p.pathPart, p.data, v)
default:
return NoMoreResults
}
if err != nil {
retu... | go | {
"resource": ""
} |
q172787 | NewNextPageIterator | validation | func NewNextPageIterator(client *Client, nextPageURI string) *PageIterator {
if nextPageURI == "" {
panic("nextpageuri is empty")
}
return &PageIterator{
data: url.Values{},
client: client,
nextPageURI: types.NullString{Valid: true, String: nextPageURI},
pathPart: "",
count: 0,
}
} | go | {
"resource": ""
} |
q172788 | containsResultsInRange | validation | func containsResultsInRange(start time.Time, end time.Time, results []time.Time) bool {
for _, result := range results {
if (result.Equal(start) || result.After(start)) && result.Before(end) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q172789 | indexesOutsideRange | validation | func indexesOutsideRange(start time.Time, end time.Time, results []time.Time) []int {
if start.After(end) {
panic("start date is after end date")
}
indexes := make([]int, 0, len(results))
for i, result := range results {
if result.Equal(end) || result.After(end) {
indexes = append(indexes, i)
}
if result... | go | {
"resource": ""
} |
q172790 | NewDefaultLogger | validation | func NewDefaultLogger(fileDir, fileName string) *FileLogger {
return NewSizeLogger(fileDir, fileName, "",
DEFAULT_FILE_COUNT, DEFAULT_FILE_SIZE, DEFAULT_FILE_UNIT, DEFAULT_LOG_SCAN, DEFAULT_LOG_SEQ)
} | go | {
"resource": ""
} |
q172791 | initLoggerBySize | validation | func (f *FileLogger) initLoggerBySize() {
f.mu.Lock()
defer f.mu.Unlock()
logFile := joinFilePath(f.fileDir, f.fileName)
for i := 1; i <= f.fileCount; i++ {
if !isExist(logFile + "." + strconv.Itoa(i)) {
break
}
f.suffix = i
}
if !f.isMustSplit() {
if !isExist(f.fileDir) {
os.Mkdir(f.fileDir, 07... | go | {
"resource": ""
} |
q172792 | initLoggerByDaily | validation | func (f *FileLogger) initLoggerByDaily() {
t, _ := time.Parse(DATEFORMAT, time.Now().Format(DATEFORMAT))
f.date = &t
f.mu.Lock()
defer f.mu.Unlock()
logFile := joinFilePath(f.fileDir, f.fileName)
if !f.isMustSplit() {
if !isExist(f.fileDir) {
os.Mkdir(f.fileDir, 0755)
}
f.logFile, _ = os.OpenFile(logF... | go | {
"resource": ""
} |
q172793 | fileMonitor | validation | func (f *FileLogger) fileMonitor() {
defer func() {
if err := recover(); err != nil {
f.lg.Printf("FileLogger's FileMonitor() catch panic: %v\n", err)
}
}()
//TODO load logScan interval from config file
logScan := DEFAULT_LOG_SCAN
timer := time.NewTicker(time.Duration(logScan) * time.Second)
for {
sel... | go | {
"resource": ""
} |
q172794 | fileCheck | validation | func (f *FileLogger) fileCheck() {
defer func() {
if err := recover(); err != nil {
f.lg.Printf("FileLogger's FileCheck() catch panic: %v\n", err)
}
}()
if f.isMustSplit() {
f.mu.Lock()
defer f.mu.Unlock()
f.split()
}
} | go | {
"resource": ""
} |
q172795 | Close | validation | func (f *FileLogger) Close() error {
close(f.logChan)
f.lg = nil
return f.logFile.Close()
} | go | {
"resource": ""
} |
q172796 | logWriter | validation | func (f *FileLogger) logWriter() {
defer func() {
if err := recover(); err != nil {
log.Printf("FileLogger's LogWritter() catch panic: %v\n", err)
}
}()
//TODO let printInterVal can be configure, without change sourceCode
printInterval := DEFAULT_PRINT_INTERVAL
seqTimer := time.NewTicker(time.Duration(pri... | go | {
"resource": ""
} |
q172797 | Printf | validation | func (f *FileLogger) Printf(format string, v ...interface{}) {
_, file, line, _ := runtime.Caller(1) //calldepth=2
f.logChan <- fmt.Sprintf("[%v:%v]", shortFileName(file), line) + fmt.Sprintf(format, v...)
} | go | {
"resource": ""
} |
q172798 | Print | validation | func (f *FileLogger) Print(v ...interface{}) {
_, file, line, _ := runtime.Caller(1) //calldepth=2
f.logChan <- fmt.Sprintf("[%v:%v]", shortFileName(file), line) + fmt.Sprint(v...)
} | go | {
"resource": ""
} |
q172799 | Println | validation | func (f *FileLogger) Println(v ...interface{}) {
_, file, line, _ := runtime.Caller(1) //calldepth=2
f.logChan <- fmt.Sprintf("[%v:%v]", shortFileName(file), line) + fmt.Sprintln(v...)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.