_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q30600 | ImportReader | train | func ImportReader(r io.Reader) (*Instagram, error) {
url, err := neturl.Parse(goInstaAPIUrl)
if err != nil {
return nil, err
}
bytes, err := ioutil.ReadAll(r)
if err != nil {
return nil, err
}
config := ConfigFile{}
err = json.Unmarshal(bytes, &config)
if err != nil {
return nil, err
}
inst := &Insta... | go | {
"resource": ""
} |
q30601 | Import | train | func Import(path string) (*Instagram, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return ImportReader(f)
} | go | {
"resource": ""
} |
q30602 | Login | train | func (inst *Instagram) Login() error {
err := inst.readMsisdnHeader()
if err != nil {
return err
}
err = inst.syncFeatures()
if err != nil {
return err
}
err = inst.zrToken()
if err != nil {
return err
}
err = inst.sendAdID()
if err != nil {
return err
}
err = inst.contactPrefill()
if err != n... | go | {
"resource": ""
} |
q30603 | Logout | train | func (inst *Instagram) Logout() error {
_, err := inst.sendSimpleRequest(urlLogout)
inst.c.Jar = nil
inst.c = nil
return err
} | go | {
"resource": ""
} |
q30604 | User | train | func (search *Search) User(user string) (*SearchResult, error) {
insta := search.inst
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlSearchUser,
Query: map[string]string{
"ig_sig_key_version": goInstaSigKeyVersion,
"is_typeahead": "true",
"query": user,
"rank_toke... | go | {
"resource": ""
} |
q30605 | Tags | train | func (search *Search) Tags(tag string) (*SearchResult, error) {
insta := search.inst
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlSearchTag,
Query: map[string]string{
"is_typeahead": "true",
"rank_token": insta.rankToken,
"q": tag,
},
},
)
if err != nil {
return ... | go | {
"resource": ""
} |
q30606 | Facebook | train | func (search *Search) Facebook(user string) (*SearchResult, error) {
insta := search.inst
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlSearchFacebook,
Query: map[string]string{
"query": user,
"rank_token": insta.rankToken,
},
},
)
if err != nil {
return nil, err
}
res := &... | go | {
"resource": ""
} |
q30607 | GetBest | train | func (img Images) GetBest() string {
best := ""
var mh, mw int
for _, v := range img.Versions {
if v.Width > mw || v.Height > mh {
best = v.URL
mh, mw = v.Height, v.Width
}
}
return best
} | go | {
"resource": ""
} |
q30608 | Unblock | train | func (b *BlockedUser) Unblock() error {
u := User{ID: b.UserID}
return u.Unblock()
} | go | {
"resource": ""
} |
q30609 | getImageDimensionFromReader | train | func getImageDimensionFromReader(rdr io.Reader) (int, int, error) {
image, _, err := image.DecodeConfig(rdr)
if err != nil {
return 0, 0, err
}
return image.Width, image.Height, nil
} | go | {
"resource": ""
} |
q30610 | Sync | train | func (account *Account) Sync() error {
insta := account.inst
data, err := insta.prepareData()
if err != nil {
return err
}
body, err := insta.sendRequest(&reqOptions{
Endpoint: urlCurrentUser,
Query: generateSignature(data),
IsPost: true,
})
if err == nil {
resp := profResp{}
err = json.Unmarsha... | go | {
"resource": ""
} |
q30611 | Saved | train | func (account *Account) Saved() (*SavedMedia, error) {
body, err := account.inst.sendSimpleRequest(urlUserTags, account.ID)
if err == nil {
media := &SavedMedia{}
err = json.Unmarshal(body, &media)
return media, err
}
return nil, err
} | go | {
"resource": ""
} |
q30612 | SetBiography | train | func (account *Account) SetBiography(bio string) error {
account.edit() // preparing to edit
insta := account.inst
data, err := insta.prepareData(
map[string]interface{}{
"raw_text": bio,
},
)
if err != nil {
return err
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlSetBiography,
Q... | go | {
"resource": ""
} |
q30613 | Liked | train | func (account *Account) Liked() *FeedMedia {
insta := account.inst
media := &FeedMedia{}
media.inst = insta
media.endpoint = urlFeedLiked
return media
} | go | {
"resource": ""
} |
q30614 | PendingFollowRequests | train | func (account *Account) PendingFollowRequests() ([]User, error) {
insta := account.inst
resp, err := insta.sendRequest(
&reqOptions{
Endpoint: urlFriendshipPending,
},
)
if err != nil {
return nil, err
}
var result struct {
Users []User `json:"users"`
// TODO: pagination
// TODO: SuggestedUsers
... | go | {
"resource": ""
} |
q30615 | LocationID | train | func (feed *Feed) LocationID(locationID int64) (*FeedLocation, error) {
insta := feed.inst
body, err := insta.sendRequest(
&reqOptions{
Endpoint: fmt.Sprintf(urlFeedLocationID, locationID),
Query: map[string]string{
"rank_token": insta.rankToken,
"ranked_content": "true",
},
},
)
if err != ... | go | {
"resource": ""
} |
q30616 | SyncLikers | train | func (item *Item) SyncLikers() error {
resp := respLikers{}
insta := item.media.instagram()
body, err := insta.sendSimpleRequest(urlMediaLikers, item.ID)
if err != nil {
return err
}
err = json.Unmarshal(body, &resp)
if err == nil {
item.Likers = resp.Users
}
return err
} | go | {
"resource": ""
} |
q30617 | ID | train | func (media *StoryMedia) ID() string {
switch id := media.Pk.(type) {
case int64:
return strconv.FormatInt(id, 10)
case string:
return id
}
return ""
} | go | {
"resource": ""
} |
q30618 | Sync | train | func (media *StoryMedia) Sync() error {
insta := media.inst
query := []trayRequest{
{"SUPPORTED_SDK_VERSIONS", "9.0,10.0,11.0,12.0,13.0,14.0,15.0,16.0,17.0,18.0,19.0,20.0,21.0,22.0,23.0,24.0"},
{"FACE_TRACKER_VERSION", "10"},
{"segmentation", "segmentation_enabled"},
{"COMPRESSION", "ETC2_COMPRESSION"},
}
q... | go | {
"resource": ""
} |
q30619 | Sync | train | func (media *FeedMedia) Sync() error {
id := media.ID()
insta := media.inst
data, err := insta.prepareData(
map[string]interface{}{
"media_id": id,
},
)
if err != nil {
return err
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: fmt.Sprintf(urlMediaInfo, id),
Query: generateSignatur... | go | {
"resource": ""
} |
q30620 | ID | train | func (media *FeedMedia) ID() string {
switch s := media.NextID.(type) {
case string:
return s
case int64:
return strconv.FormatInt(s, 10)
case json.Number:
return string(s)
}
return ""
} | go | {
"resource": ""
} |
q30621 | Write | train | func (c *Conversation) Write(b []byte) (int, error) {
n := len(b)
return n, c.Send(b2s(b))
} | go | {
"resource": ""
} |
q30622 | Next | train | func (comments *Comments) Next() bool {
if comments.err != nil {
return false
}
item := comments.item
insta := item.media.instagram()
endpoint := comments.endpoint
query := map[string]string{
// "can_support_threading": "true",
}
if comments.NextMaxID != nil {
next, _ := strconv.Unquote(string(comments.N... | go | {
"resource": ""
} |
q30623 | Del | train | func (comments *Comments) Del(comment *Comment) error {
insta := comments.item.media.instagram()
data, err := insta.prepareData()
if err != nil {
return err
}
id := comment.getid()
_, err = insta.sendRequest(
&reqOptions{
Endpoint: fmt.Sprintf(urlCommentDelete, comments.item.ID, id),
Query: generat... | go | {
"resource": ""
} |
q30624 | Like | train | func (c *Comment) Like() error {
data, err := c.inst.prepareData()
if err != nil {
return err
}
_, err = c.inst.sendRequest(
&reqOptions{
Endpoint: fmt.Sprintf(urlCommentLike, c.getid()),
Query: generateSignature(data),
IsPost: true,
},
)
return err
} | go | {
"resource": ""
} |
q30625 | NewHashtag | train | func (inst *Instagram) NewHashtag(name string) *Hashtag {
return &Hashtag{
inst: inst,
Name: name,
}
} | go | {
"resource": ""
} |
q30626 | Sync | train | func (h *Hashtag) Sync() error {
insta := h.inst
body, err := insta.sendSimpleRequest(urlTagSync, h.Name)
if err == nil {
var resp struct {
Name string `json:"name"`
ID int64 `json:"id"`
MediaCount int `json:"media_count"`
}
err = json.Unmarshal(body, &resp)
if err == nil {
h.N... | go | {
"resource": ""
} |
q30627 | Stories | train | func (h *Hashtag) Stories() (*StoryMedia, error) {
body, err := h.inst.sendSimpleRequest(
urlTagStories, h.Name,
)
if err == nil {
var resp struct {
Story StoryMedia `json:"story"`
Status string `json:"status"`
}
err = json.Unmarshal(body, &resp)
return &resp.Story, err
}
return nil, err
} | go | {
"resource": ""
} |
q30628 | Blocked | train | func (prof *Profiles) Blocked() ([]BlockedUser, error) {
body, err := prof.inst.sendSimpleRequest(urlBlockedList)
if err == nil {
resp := blockedListResp{}
err = json.Unmarshal(body, &resp)
return resp.BlockedList, err
}
return nil, err
} | go | {
"resource": ""
} |
q30629 | MarshalJSON | train | func (v Uint64) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
v.MarshalEasyJSON(&w)
return w.Buffer.BuildBytes(), w.Error
} | go | {
"resource": ""
} |
q30630 | UnmarshalJSON | train | func (v *Uint64) UnmarshalJSON(data []byte) error {
l := jlexer.Lexer{Data: data}
v.UnmarshalEasyJSON(&l)
return l.Error()
} | go | {
"resource": ""
} |
q30631 | genTypeDecoder | train | func (g *Generator) genTypeDecoder(t reflect.Type, out string, tags fieldTags, indent int) error {
ws := strings.Repeat(" ", indent)
unmarshalerIface := reflect.TypeOf((*easyjson.Unmarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(unmarshalerIface) {
fmt.Fprintln(g.out, ws+"("+out+").UnmarshalEasyJSON(in)")... | go | {
"resource": ""
} |
q30632 | hasCustomUnmarshaler | train | func hasCustomUnmarshaler(t reflect.Type) bool {
t = reflect.PtrTo(t)
return t.Implements(reflect.TypeOf((*easyjson.Unmarshaler)(nil)).Elem()) ||
t.Implements(reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()) ||
t.Implements(reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem())
} | go | {
"resource": ""
} |
q30633 | String | train | func (v Float32) String() string {
if !v.Defined {
return "<undefined>"
}
return fmt.Sprint(v.V)
} | go | {
"resource": ""
} |
q30634 | NewGenerator | train | func NewGenerator(filename string) *Generator {
ret := &Generator{
imports: map[string]string{
pkgWriter: "jwriter",
pkgLexer: "jlexer",
pkgEasyJSON: "easyjson",
"encoding/json": "json",
},
fieldNamer: DefaultFieldNamer{},
marshalers: make(map[reflect.Type]bool),
typesSeen:... | go | {
"resource": ""
} |
q30635 | SetPkg | train | func (g *Generator) SetPkg(name, path string) {
g.pkgName = name
g.pkgPath = path
} | go | {
"resource": ""
} |
q30636 | printHeader | train | func (g *Generator) printHeader() {
if g.buildTags != "" {
fmt.Println("// +build ", g.buildTags)
fmt.Println()
}
fmt.Println("// Code generated by easyjson for marshaling/unmarshaling. DO NOT EDIT.")
fmt.Println()
fmt.Println("package ", g.pkgName)
fmt.Println()
byAlias := map[string]string{}
var aliases ... | go | {
"resource": ""
} |
q30637 | Run | train | func (g *Generator) Run(out io.Writer) error {
g.out = &bytes.Buffer{}
for len(g.typesUnseen) > 0 {
t := g.typesUnseen[len(g.typesUnseen)-1]
g.typesUnseen = g.typesUnseen[:len(g.typesUnseen)-1]
g.typesSeen[t] = true
if err := g.genDecoder(t); err != nil {
return err
}
if err := g.genEncoder(t); err !... | go | {
"resource": ""
} |
q30638 | fixPkgPathVendoring | train | func fixPkgPathVendoring(pkgPath string) string {
const vendor = "/vendor/"
if i := strings.LastIndex(pkgPath, vendor); i != -1 {
return pkgPath[i+len(vendor):]
}
return pkgPath
} | go | {
"resource": ""
} |
q30639 | pkgAlias | train | func (g *Generator) pkgAlias(pkgPath string) string {
pkgPath = fixPkgPathVendoring(pkgPath)
if alias := g.imports[pkgPath]; alias != "" {
return alias
}
for i := 0; ; i++ {
alias := fixAliasName(path.Base(pkgPath))
if i > 0 {
alias += fmt.Sprint(i)
}
exists := false
for _, v := range g.imports {
... | go | {
"resource": ""
} |
q30640 | getType | train | func (g *Generator) getType(t reflect.Type) string {
if t.Name() == "" {
switch t.Kind() {
case reflect.Ptr:
return "*" + g.getType(t.Elem())
case reflect.Slice:
return "[]" + g.getType(t.Elem())
case reflect.Array:
return "[" + strconv.Itoa(t.Len()) + "]" + g.getType(t.Elem())
case reflect.Map:
... | go | {
"resource": ""
} |
q30641 | escapeTag | train | func escapeTag(tag reflect.StructTag) string {
t := string(tag)
if strings.ContainsRune(t, '`') {
// there are ` in the string; we can't use ` to enclose the string
return strconv.Quote(t)
}
return "`" + t + "`"
} | go | {
"resource": ""
} |
q30642 | uniqueVarName | train | func (g *Generator) uniqueVarName() string {
g.varCounter++
return fmt.Sprint("v", g.varCounter)
} | go | {
"resource": ""
} |
q30643 | lowerFirst | train | func lowerFirst(s string) string {
if s == "" {
return ""
}
str := ""
strlen := len(s)
/**
Loop each char
If is uppercase:
If is first char, LOWER it
If the following char is lower, LEAVE it
If the following char is upper OR numeric, LOWER it
If is the end of string, LEAVE it
Else ... | go | {
"resource": ""
} |
q30644 | parseFieldTags | train | func parseFieldTags(f reflect.StructField) fieldTags {
var ret fieldTags
for i, s := range strings.Split(f.Tag.Get("json"), ",") {
switch {
case i == 0 && s == "-":
ret.omit = true
case i == 0:
ret.name = s
case s == "omitempty":
ret.omitEmpty = true
case s == "!omitempty":
ret.noOmitEmpty = tr... | go | {
"resource": ""
} |
q30645 | genTypeEncoder | train | func (g *Generator) genTypeEncoder(t reflect.Type, in string, tags fieldTags, indent int, assumeNonEmpty bool) error {
ws := strings.Repeat(" ", indent)
marshalerIface := reflect.TypeOf((*easyjson.Marshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(marshalerIface) {
fmt.Fprintln(g.out, ws+"("+in+").MarshalEas... | go | {
"resource": ""
} |
q30646 | hasCustomMarshaler | train | func hasCustomMarshaler(t reflect.Type) bool {
t = reflect.PtrTo(t)
return t.Implements(reflect.TypeOf((*easyjson.Marshaler)(nil)).Elem()) ||
t.Implements(reflect.TypeOf((*json.Marshaler)(nil)).Elem()) ||
t.Implements(reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem())
} | go | {
"resource": ""
} |
q30647 | genTypeEncoderNoCheck | train | func (g *Generator) genTypeEncoderNoCheck(t reflect.Type, in string, tags fieldTags, indent int, assumeNonEmpty bool) error {
ws := strings.Repeat(" ", indent)
// Check whether type is primitive, needs to be done after interface check.
if enc := primitiveStringEncoders[t.Kind()]; enc != "" && tags.asString {
fmt... | go | {
"resource": ""
} |
q30648 | writeMain | train | func (g *Generator) writeMain() (path string, err error) {
f, err := ioutil.TempFile(filepath.Dir(g.OutName), "easyjson-bootstrap")
if err != nil {
return "", err
}
fmt.Fprintln(f, "// +build ignore")
fmt.Fprintln(f)
fmt.Fprintln(f, "// TEMPORARY AUTOGENERATED FILE: easyjson bootstapping code to launch")
fmt.... | go | {
"resource": ""
} |
q30649 | DumpTo | train | func (w *Writer) DumpTo(out io.Writer) (written int, err error) {
return w.Buffer.DumpTo(out)
} | go | {
"resource": ""
} |
q30650 | BuildBytes | train | func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.BuildBytes(reuse...), nil
} | go | {
"resource": ""
} |
q30651 | ReadCloser | train | func (w *Writer) ReadCloser() (io.ReadCloser, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.ReadCloser(), nil
} | go | {
"resource": ""
} |
q30652 | Raw | train | func (w *Writer) Raw(data []byte, err error) {
switch {
case w.Error != nil:
return
case err != nil:
w.Error = err
case len(data) > 0:
w.Buffer.AppendBytes(data)
default:
w.RawString("null")
}
} | go | {
"resource": ""
} |
q30653 | RawText | train | func (w *Writer) RawText(data []byte, err error) {
switch {
case w.Error != nil:
return
case err != nil:
w.Error = err
case len(data) > 0:
w.String(string(data))
default:
w.RawString("null")
}
} | go | {
"resource": ""
} |
q30654 | Base64Bytes | train | func (w *Writer) Base64Bytes(data []byte) {
if data == nil {
w.Buffer.AppendString("null")
return
}
w.Buffer.AppendByte('"')
w.base64(data)
w.Buffer.AppendByte('"')
} | go | {
"resource": ""
} |
q30655 | goModPath | train | func goModPath(fname string, isDir bool) (string, error) {
root := fname
if !isDir {
root = filepath.Dir(fname)
}
goModPathCache.RLock()
goModPath, ok := goModPathCache.paths[root]
goModPathCache.RUnlock()
if ok {
return goModPath, nil
}
defer func() {
goModPathCache.Lock()
goModPathCache.paths[root]... | go | {
"resource": ""
} |
q30656 | putBuf | train | func putBuf(buf []byte) {
size := cap(buf)
if size < config.PooledSize {
return
}
if c := buffers[size]; c != nil {
c.Put(buf[:0])
}
} | go | {
"resource": ""
} |
q30657 | getBuf | train | func getBuf(size int) []byte {
if size < config.PooledSize {
return make([]byte, 0, size)
}
if c := buffers[size]; c != nil {
v := c.Get()
if v != nil {
return v.([]byte)
}
}
return make([]byte, 0, size)
} | go | {
"resource": ""
} |
q30658 | EnsureSpace | train | func (b *Buffer) EnsureSpace(s int) {
if cap(b.Buf)-len(b.Buf) >= s {
return
}
l := len(b.Buf)
if l > 0 {
if cap(b.toPool) != cap(b.Buf) {
// Chunk was reallocated, toPool can be pooled.
putBuf(b.toPool)
}
if cap(b.bufs) == 0 {
b.bufs = make([][]byte, 0, 8)
}
b.bufs = append(b.bufs, b.Buf)
l ... | go | {
"resource": ""
} |
q30659 | AppendByte | train | func (b *Buffer) AppendByte(data byte) {
if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
b.EnsureSpace(1)
}
b.Buf = append(b.Buf, data)
} | go | {
"resource": ""
} |
q30660 | AppendBytes | train | func (b *Buffer) AppendBytes(data []byte) {
for len(data) > 0 {
if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
b.EnsureSpace(1)
}
sz := cap(b.Buf) - len(b.Buf)
if sz > len(data) {
sz = len(data)
}
b.Buf = append(b.Buf, data[:sz]...)
data = data[sz:]
}
} | go | {
"resource": ""
} |
q30661 | AppendString | train | func (b *Buffer) AppendString(data string) {
for len(data) > 0 {
if cap(b.Buf) == len(b.Buf) { // EnsureSpace won't be inlined.
b.EnsureSpace(1)
}
sz := cap(b.Buf) - len(b.Buf)
if sz > len(data) {
sz = len(data)
}
b.Buf = append(b.Buf, data[:sz]...)
data = data[sz:]
}
} | go | {
"resource": ""
} |
q30662 | Size | train | func (b *Buffer) Size() int {
size := len(b.Buf)
for _, buf := range b.bufs {
size += len(buf)
}
return size
} | go | {
"resource": ""
} |
q30663 | DumpTo | train | func (b *Buffer) DumpTo(w io.Writer) (written int, err error) {
var n int
for _, buf := range b.bufs {
if err == nil {
n, err = w.Write(buf)
written += n
}
putBuf(buf)
}
if err == nil {
n, err = w.Write(b.Buf)
written += n
}
putBuf(b.toPool)
b.bufs = nil
b.Buf = nil
b.toPool = nil
return
} | go | {
"resource": ""
} |
q30664 | BuildBytes | train | func (b *Buffer) BuildBytes(reuse ...[]byte) []byte {
if len(b.bufs) == 0 {
ret := b.Buf
b.toPool = nil
b.Buf = nil
return ret
}
var ret []byte
size := b.Size()
// If we got a buffer as argument and it is big enought, reuse it.
if len(reuse) == 1 && cap(reuse[0]) >= size {
ret = reuse[0][:0]
} else {... | go | {
"resource": ""
} |
q30665 | ReadCloser | train | func (b *Buffer) ReadCloser() io.ReadCloser {
ret := &readCloser{0, append(b.bufs, b.Buf)}
b.bufs = nil
b.toPool = nil
b.Buf = nil
return ret
} | go | {
"resource": ""
} |
q30666 | FetchToken | train | func (r *Lexer) FetchToken() {
r.token.kind = tokenUndef
r.start = r.pos
// Check if r.Data has r.pos element
// If it doesn't, it mean corrupted input data
if len(r.Data) < r.pos {
r.errParse("Unexpected end of data")
return
}
// Determine the type of a token by skipping whitespace and reading the
// firs... | go | {
"resource": ""
} |
q30667 | isTokenEnd | train | func isTokenEnd(c byte) bool {
return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '[' || c == ']' || c == '{' || c == '}' || c == ',' || c == ':'
} | go | {
"resource": ""
} |
q30668 | fetchNull | train | func (r *Lexer) fetchNull() {
r.pos += 4
if r.pos > len(r.Data) ||
r.Data[r.pos-3] != 'u' ||
r.Data[r.pos-2] != 'l' ||
r.Data[r.pos-1] != 'l' ||
(r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) {
r.pos -= 4
r.errSyntax()
}
} | go | {
"resource": ""
} |
q30669 | fetchTrue | train | func (r *Lexer) fetchTrue() {
r.pos += 4
if r.pos > len(r.Data) ||
r.Data[r.pos-3] != 'r' ||
r.Data[r.pos-2] != 'u' ||
r.Data[r.pos-1] != 'e' ||
(r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) {
r.pos -= 4
r.errSyntax()
}
} | go | {
"resource": ""
} |
q30670 | fetchFalse | train | func (r *Lexer) fetchFalse() {
r.pos += 5
if r.pos > len(r.Data) ||
r.Data[r.pos-4] != 'a' ||
r.Data[r.pos-3] != 'l' ||
r.Data[r.pos-2] != 's' ||
r.Data[r.pos-1] != 'e' ||
(r.pos != len(r.Data) && !isTokenEnd(r.Data[r.pos])) {
r.pos -= 5
r.errSyntax()
}
} | go | {
"resource": ""
} |
q30671 | fetchNumber | train | func (r *Lexer) fetchNumber() {
hasE := false
afterE := false
hasDot := false
r.pos++
for i, c := range r.Data[r.pos:] {
switch {
case c >= '0' && c <= '9':
afterE = false
case c == '.' && !hasDot:
hasDot = true
case (c == 'e' || c == 'E') && !hasE:
hasE = true
hasDot = true
afterE = true
... | go | {
"resource": ""
} |
q30672 | findStringLen | train | func findStringLen(data []byte) (isValid, hasEscapes bool, length int) {
delta := 0
for i := 0; i < len(data); i++ {
switch data[i] {
case '\\':
i++
delta++
if i < len(data) && data[i] == 'u' {
delta++
}
case '"':
return true, (delta > 0), (i - delta)
}
}
return false, false, len(data)
... | go | {
"resource": ""
} |
q30673 | processEscape | train | func (r *Lexer) processEscape(data []byte) (int, error) {
if len(data) < 2 {
return 0, fmt.Errorf("syntax error at %v", string(data))
}
c := data[1]
switch c {
case '"', '/', '\\':
r.token.byteValue = append(r.token.byteValue, c)
return 2, nil
case 'b':
r.token.byteValue = append(r.token.byteValue, '\b')... | go | {
"resource": ""
} |
q30674 | fetchString | train | func (r *Lexer) fetchString() {
r.pos++
data := r.Data[r.pos:]
isValid, hasEscapes, length := findStringLen(data)
if !isValid {
r.pos += length
r.errParse("unterminated string literal")
return
}
if !hasEscapes {
r.token.byteValue = data[:length]
r.pos += length + 1
return
}
r.token.byteValue = mak... | go | {
"resource": ""
} |
q30675 | scanToken | train | func (r *Lexer) scanToken() {
if r.token.kind != tokenUndef || r.fatalError != nil {
return
}
r.FetchToken()
} | go | {
"resource": ""
} |
q30676 | consume | train | func (r *Lexer) consume() {
r.token.kind = tokenUndef
r.token.delimValue = 0
} | go | {
"resource": ""
} |
q30677 | Delim | train | func (r *Lexer) Delim(c byte) {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
if !r.Ok() || r.token.delimValue != c {
r.consume() // errInvalidToken can change token if UseMultipleErrors is enabled.
r.errInvalidToken(string([]byte{c}))
} else {
r.consume()
}
} | go | {
"resource": ""
} |
q30678 | IsDelim | train | func (r *Lexer) IsDelim(c byte) bool {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
return !r.Ok() || r.token.delimValue == c
} | go | {
"resource": ""
} |
q30679 | Null | train | func (r *Lexer) Null() {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
if !r.Ok() || r.token.kind != tokenNull {
r.errInvalidToken("null")
}
r.consume()
} | go | {
"resource": ""
} |
q30680 | IsNull | train | func (r *Lexer) IsNull() bool {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
return r.Ok() && r.token.kind == tokenNull
} | go | {
"resource": ""
} |
q30681 | Skip | train | func (r *Lexer) Skip() {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
r.consume()
} | go | {
"resource": ""
} |
q30682 | Raw | train | func (r *Lexer) Raw() []byte {
r.SkipRecursive()
if !r.Ok() {
return nil
}
return r.Data[r.start:r.pos]
} | go | {
"resource": ""
} |
q30683 | Consumed | train | func (r *Lexer) Consumed() {
if r.pos > len(r.Data) || !r.Ok() {
return
}
for _, c := range r.Data[r.pos:] {
if c != ' ' && c != '\t' && c != '\r' && c != '\n' {
r.AddError(&LexerError{
Reason: "invalid character '" + string(c) + "' after top-level value",
Offset: r.pos,
Data: string(r.Data[r.p... | go | {
"resource": ""
} |
q30684 | String | train | func (r *Lexer) String() string {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
if !r.Ok() || r.token.kind != tokenString {
r.errInvalidToken("string")
return ""
}
ret := string(r.token.byteValue)
r.consume()
return ret
} | go | {
"resource": ""
} |
q30685 | Bytes | train | func (r *Lexer) Bytes() []byte {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
if !r.Ok() || r.token.kind != tokenString {
r.errInvalidToken("string")
return nil
}
ret := make([]byte, base64.StdEncoding.DecodedLen(len(r.token.byteValue)))
n, err := base64.StdEncoding.Decode(ret, r.token.byteVal... | go | {
"resource": ""
} |
q30686 | Bool | train | func (r *Lexer) Bool() bool {
if r.token.kind == tokenUndef && r.Ok() {
r.FetchToken()
}
if !r.Ok() || r.token.kind != tokenBool {
r.errInvalidToken("bool")
return false
}
ret := r.token.boolValue
r.consume()
return ret
} | go | {
"resource": ""
} |
q30687 | Marshal | train | func Marshal(v Marshaler) ([]byte, error) {
w := jwriter.Writer{}
v.MarshalEasyJSON(&w)
return w.BuildBytes()
} | go | {
"resource": ""
} |
q30688 | MarshalToWriter | train | func MarshalToWriter(v Marshaler, w io.Writer) (written int, err error) {
jw := jwriter.Writer{}
v.MarshalEasyJSON(&jw)
return jw.DumpTo(w)
} | go | {
"resource": ""
} |
q30689 | Unmarshal | train | func Unmarshal(data []byte, v Unmarshaler) error {
l := jlexer.Lexer{Data: data}
v.UnmarshalEasyJSON(&l)
return l.Error()
} | go | {
"resource": ""
} |
q30690 | UnmarshalFromReader | train | func UnmarshalFromReader(r io.Reader, v Unmarshaler) error {
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
l := jlexer.Lexer{Data: data}
v.UnmarshalEasyJSON(&l)
return l.Error()
} | go | {
"resource": ""
} |
q30691 | Less | train | func (s stops) Less(i, j int) bool {
return s[i].pos < s[j].pos
} | go | {
"resource": ""
} |
q30692 | Swap | train | func (s stops) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q30693 | LoadFontFace | train | func LoadFontFace(path string, points float64) (font.Face, error) {
fontBytes, err := ioutil.ReadFile(path)
if err != nil {
return nil, err
}
f, err := truetype.Parse(fontBytes)
if err != nil {
return nil, err
}
face := truetype.NewFace(f, &truetype.Options{
Size: points,
// Hinting: font.HintingFull,
}... | go | {
"resource": ""
} |
q30694 | NewContext | train | func NewContext(width, height int) *Context {
return NewContextForRGBA(image.NewRGBA(image.Rect(0, 0, width, height)))
} | go | {
"resource": ""
} |
q30695 | NewContextForRGBA | train | func NewContextForRGBA(im *image.RGBA) *Context {
w := im.Bounds().Size().X
h := im.Bounds().Size().Y
return &Context{
width: w,
height: h,
rasterizer: raster.NewRasterizer(w, h),
im: im,
color: color.Transparent,
fillPattern: defaultFillStyle,
strokePattern: defa... | go | {
"resource": ""
} |
q30696 | GetCurrentPoint | train | func (dc *Context) GetCurrentPoint() (Point, bool) {
if dc.hasCurrent {
return dc.current, true
}
return Point{}, false
} | go | {
"resource": ""
} |
q30697 | SavePNG | train | func (dc *Context) SavePNG(path string) error {
return SavePNG(path, dc.im)
} | go | {
"resource": ""
} |
q30698 | SaveJPG | train | func (dc *Context) SaveJPG(path string, quality int) error {
return SaveJPG(path, dc.im, quality)
} | go | {
"resource": ""
} |
q30699 | EncodePNG | train | func (dc *Context) EncodePNG(w io.Writer) error {
return png.Encode(w, dc.im)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.