repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
sequence | docstring
stringlengths 6
2.61k
| docstring_tokens
sequence | sha
stringlengths 40
40
| url
stringlengths 85
252
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
sevlyar/go-daemon | command.go | SendCommands | func SendCommands(p *os.Process) (err error) {
for _, sig := range signals() {
if err = p.Signal(sig); err != nil {
return
}
}
return
} | go | func SendCommands(p *os.Process) (err error) {
for _, sig := range signals() {
if err = p.Signal(sig); err != nil {
return
}
}
return
} | [
"func",
"SendCommands",
"(",
"p",
"*",
"os",
".",
"Process",
")",
"(",
"err",
"error",
")",
"{",
"for",
"_",
",",
"sig",
":=",
"range",
"signals",
"(",
")",
"{",
"if",
"err",
"=",
"p",
".",
"Signal",
"(",
"sig",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // SendCommands sends active signals to the given process. | [
"SendCommands",
"sends",
"active",
"signals",
"to",
"the",
"given",
"process",
"."
] | fedf95d0cd0be92511436dbc84c290ff1c104f61 | https://github.com/sevlyar/go-daemon/blob/fedf95d0cd0be92511436dbc84c290ff1c104f61/command.go#L71-L78 | train |
sevlyar/go-daemon | command.go | ActiveFlags | func ActiveFlags() (ret []Flag) {
ret = make([]Flag, 0, 1)
for f := range flags {
if f.IsSet() {
ret = append(ret, f)
}
}
return
} | go | func ActiveFlags() (ret []Flag) {
ret = make([]Flag, 0, 1)
for f := range flags {
if f.IsSet() {
ret = append(ret, f)
}
}
return
} | [
"func",
"ActiveFlags",
"(",
")",
"(",
"ret",
"[",
"]",
"Flag",
")",
"{",
"ret",
"=",
"make",
"(",
"[",
"]",
"Flag",
",",
"0",
",",
"1",
")",
"\n",
"for",
"f",
":=",
"range",
"flags",
"{",
"if",
"f",
".",
"IsSet",
"(",
")",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"f",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] | // ActiveFlags returns flags that has the state 'set'. | [
"ActiveFlags",
"returns",
"flags",
"that",
"has",
"the",
"state",
"set",
"."
] | fedf95d0cd0be92511436dbc84c290ff1c104f61 | https://github.com/sevlyar/go-daemon/blob/fedf95d0cd0be92511436dbc84c290ff1c104f61/command.go#L81-L89 | train |
sevlyar/go-daemon | signal.go | SetSigHandler | func SetSigHandler(handler SignalHandlerFunc, signals ...os.Signal) {
for _, sig := range signals {
handlers[sig] = handler
}
} | go | func SetSigHandler(handler SignalHandlerFunc, signals ...os.Signal) {
for _, sig := range signals {
handlers[sig] = handler
}
} | [
"func",
"SetSigHandler",
"(",
"handler",
"SignalHandlerFunc",
",",
"signals",
"...",
"os",
".",
"Signal",
")",
"{",
"for",
"_",
",",
"sig",
":=",
"range",
"signals",
"{",
"handlers",
"[",
"sig",
"]",
"=",
"handler",
"\n",
"}",
"\n",
"}"
] | // SetSigHandler sets handler for the given signals.
// SIGTERM has the default handler, he returns ErrStop. | [
"SetSigHandler",
"sets",
"handler",
"for",
"the",
"given",
"signals",
".",
"SIGTERM",
"has",
"the",
"default",
"handler",
"he",
"returns",
"ErrStop",
"."
] | fedf95d0cd0be92511436dbc84c290ff1c104f61 | https://github.com/sevlyar/go-daemon/blob/fedf95d0cd0be92511436dbc84c290ff1c104f61/signal.go#L19-L23 | train |
sevlyar/go-daemon | signal.go | ServeSignals | func ServeSignals() (err error) {
signals := make([]os.Signal, 0, len(handlers))
for sig := range handlers {
signals = append(signals, sig)
}
ch := make(chan os.Signal, 8)
signal.Notify(ch, signals...)
for sig := range ch {
err = handlers[sig](sig)
if err != nil {
break
}
}
signal.Stop(ch)
if err == ErrStop {
err = nil
}
return
} | go | func ServeSignals() (err error) {
signals := make([]os.Signal, 0, len(handlers))
for sig := range handlers {
signals = append(signals, sig)
}
ch := make(chan os.Signal, 8)
signal.Notify(ch, signals...)
for sig := range ch {
err = handlers[sig](sig)
if err != nil {
break
}
}
signal.Stop(ch)
if err == ErrStop {
err = nil
}
return
} | [
"func",
"ServeSignals",
"(",
")",
"(",
"err",
"error",
")",
"{",
"signals",
":=",
"make",
"(",
"[",
"]",
"os",
".",
"Signal",
",",
"0",
",",
"len",
"(",
"handlers",
")",
")",
"\n",
"for",
"sig",
":=",
"range",
"handlers",
"{",
"signals",
"=",
"append",
"(",
"signals",
",",
"sig",
")",
"\n",
"}",
"\n\n",
"ch",
":=",
"make",
"(",
"chan",
"os",
".",
"Signal",
",",
"8",
")",
"\n",
"signal",
".",
"Notify",
"(",
"ch",
",",
"signals",
"...",
")",
"\n\n",
"for",
"sig",
":=",
"range",
"ch",
"{",
"err",
"=",
"handlers",
"[",
"sig",
"]",
"(",
"sig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"signal",
".",
"Stop",
"(",
"ch",
")",
"\n\n",
"if",
"err",
"==",
"ErrStop",
"{",
"err",
"=",
"nil",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // ServeSignals calls handlers for system signals. | [
"ServeSignals",
"calls",
"handlers",
"for",
"system",
"signals",
"."
] | fedf95d0cd0be92511436dbc84c290ff1c104f61 | https://github.com/sevlyar/go-daemon/blob/fedf95d0cd0be92511436dbc84c290ff1c104f61/signal.go#L26-L49 | train |
sevlyar/go-daemon | daemon.go | Search | func (d *Context) Search() (daemon *os.Process, err error) {
return d.search()
} | go | func (d *Context) Search() (daemon *os.Process, err error) {
return d.search()
} | [
"func",
"(",
"d",
"*",
"Context",
")",
"Search",
"(",
")",
"(",
"daemon",
"*",
"os",
".",
"Process",
",",
"err",
"error",
")",
"{",
"return",
"d",
".",
"search",
"(",
")",
"\n",
"}"
] | // Search searches daemons process by given in context pid file name.
// If success returns pointer on daemons os.Process structure,
// else returns error. Returns nil if filename is empty. | [
"Search",
"searches",
"daemons",
"process",
"by",
"given",
"in",
"context",
"pid",
"file",
"name",
".",
"If",
"success",
"returns",
"pointer",
"on",
"daemons",
"os",
".",
"Process",
"structure",
"else",
"returns",
"error",
".",
"Returns",
"nil",
"if",
"filename",
"is",
"empty",
"."
] | fedf95d0cd0be92511436dbc84c290ff1c104f61 | https://github.com/sevlyar/go-daemon/blob/fedf95d0cd0be92511436dbc84c290ff1c104f61/daemon.go#L37-L39 | train |
aelsabbahy/goss | resource/gomega.go | sanitizeExpectedValue | func sanitizeExpectedValue(i interface{}) interface{} {
if e, ok := i.(float64); ok {
return int(e)
}
if e, ok := i.(map[interface{}]interface{}); ok {
out := make(map[string]interface{})
for k, v := range e {
ks, ok := k.(string)
if !ok {
panic(fmt.Sprintf("Matcher key type not string: %T\n\n", k))
}
out[ks] = sanitizeExpectedValue(v)
}
return out
}
return i
} | go | func sanitizeExpectedValue(i interface{}) interface{} {
if e, ok := i.(float64); ok {
return int(e)
}
if e, ok := i.(map[interface{}]interface{}); ok {
out := make(map[string]interface{})
for k, v := range e {
ks, ok := k.(string)
if !ok {
panic(fmt.Sprintf("Matcher key type not string: %T\n\n", k))
}
out[ks] = sanitizeExpectedValue(v)
}
return out
}
return i
} | [
"func",
"sanitizeExpectedValue",
"(",
"i",
"interface",
"{",
"}",
")",
"interface",
"{",
"}",
"{",
"if",
"e",
",",
"ok",
":=",
"i",
".",
"(",
"float64",
")",
";",
"ok",
"{",
"return",
"int",
"(",
"e",
")",
"\n",
"}",
"\n",
"if",
"e",
",",
"ok",
":=",
"i",
".",
"(",
"map",
"[",
"interface",
"{",
"}",
"]",
"interface",
"{",
"}",
")",
";",
"ok",
"{",
"out",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"e",
"{",
"ks",
",",
"ok",
":=",
"k",
".",
"(",
"string",
")",
"\n",
"if",
"!",
"ok",
"{",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"k",
")",
")",
"\n",
"}",
"\n",
"out",
"[",
"ks",
"]",
"=",
"sanitizeExpectedValue",
"(",
"v",
")",
"\n",
"}",
"\n",
"return",
"out",
"\n",
"}",
"\n",
"return",
"i",
"\n",
"}"
] | // Normalize expectedValue so json and yaml are the same | [
"Normalize",
"expectedValue",
"so",
"json",
"and",
"yaml",
"are",
"the",
"same"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/resource/gomega.go#L160-L176 | train |
aelsabbahy/goss | system/system.go | detectPackage | func (sys *System) detectPackage(c *cli.Context) {
p := c.GlobalString("package")
if p != "deb" && p != "apk" && p != "pacman" && p != "rpm" {
p = DetectPackageManager()
}
switch p {
case "deb":
sys.NewPackage = NewDebPackage
case "apk":
sys.NewPackage = NewAlpinePackage
case "pacman":
sys.NewPackage = NewPacmanPackage
default:
sys.NewPackage = NewRpmPackage
}
} | go | func (sys *System) detectPackage(c *cli.Context) {
p := c.GlobalString("package")
if p != "deb" && p != "apk" && p != "pacman" && p != "rpm" {
p = DetectPackageManager()
}
switch p {
case "deb":
sys.NewPackage = NewDebPackage
case "apk":
sys.NewPackage = NewAlpinePackage
case "pacman":
sys.NewPackage = NewPacmanPackage
default:
sys.NewPackage = NewRpmPackage
}
} | [
"func",
"(",
"sys",
"*",
"System",
")",
"detectPackage",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"{",
"p",
":=",
"c",
".",
"GlobalString",
"(",
"\"",
"\"",
")",
"\n",
"if",
"p",
"!=",
"\"",
"\"",
"&&",
"p",
"!=",
"\"",
"\"",
"&&",
"p",
"!=",
"\"",
"\"",
"&&",
"p",
"!=",
"\"",
"\"",
"{",
"p",
"=",
"DetectPackageManager",
"(",
")",
"\n",
"}",
"\n",
"switch",
"p",
"{",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewPackage",
"=",
"NewDebPackage",
"\n",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewPackage",
"=",
"NewAlpinePackage",
"\n",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewPackage",
"=",
"NewPacmanPackage",
"\n",
"default",
":",
"sys",
".",
"NewPackage",
"=",
"NewRpmPackage",
"\n",
"}",
"\n",
"}"
] | // detectPackage adds the correct package creation function to a System struct | [
"detectPackage",
"adds",
"the",
"correct",
"package",
"creation",
"function",
"to",
"a",
"System",
"struct"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/system.go#L79-L94 | train |
aelsabbahy/goss | system/system.go | detectService | func (sys *System) detectService() {
switch DetectService() {
case "upstart":
sys.NewService = NewServiceUpstart
case "systemd":
sys.NewService = NewServiceSystemd
case "alpineinit":
sys.NewService = NewAlpineServiceInit
default:
sys.NewService = NewServiceInit
}
} | go | func (sys *System) detectService() {
switch DetectService() {
case "upstart":
sys.NewService = NewServiceUpstart
case "systemd":
sys.NewService = NewServiceSystemd
case "alpineinit":
sys.NewService = NewAlpineServiceInit
default:
sys.NewService = NewServiceInit
}
} | [
"func",
"(",
"sys",
"*",
"System",
")",
"detectService",
"(",
")",
"{",
"switch",
"DetectService",
"(",
")",
"{",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewService",
"=",
"NewServiceUpstart",
"\n",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewService",
"=",
"NewServiceSystemd",
"\n",
"case",
"\"",
"\"",
":",
"sys",
".",
"NewService",
"=",
"NewAlpineServiceInit",
"\n",
"default",
":",
"sys",
".",
"NewService",
"=",
"NewServiceInit",
"\n",
"}",
"\n",
"}"
] | // detectService adds the correct service creation function to a System struct | [
"detectService",
"adds",
"the",
"correct",
"service",
"creation",
"function",
"to",
"a",
"System",
"struct"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/system.go#L97-L108 | train |
aelsabbahy/goss | system/system.go | HasCommand | func HasCommand(cmd string) bool {
if _, err := exec.LookPath(cmd); err == nil {
return true
}
return false
} | go | func HasCommand(cmd string) bool {
if _, err := exec.LookPath(cmd); err == nil {
return true
}
return false
} | [
"func",
"HasCommand",
"(",
"cmd",
"string",
")",
"bool",
"{",
"if",
"_",
",",
"err",
":=",
"exec",
".",
"LookPath",
"(",
"cmd",
")",
";",
"err",
"==",
"nil",
"{",
"return",
"true",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] | // HasCommand returns whether or not an executable by this name is on the PATH. | [
"HasCommand",
"returns",
"whether",
"or",
"not",
"an",
"executable",
"by",
"this",
"name",
"is",
"on",
"the",
"PATH",
"."
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/system.go#L174-L179 | train |
aelsabbahy/goss | store.go | ReadJSON | func ReadJSON(filePath string) GossConfig {
file, err := ioutil.ReadFile(filePath)
if err != nil {
fmt.Printf("File error: %v\n", err)
os.Exit(1)
}
return ReadJSONData(file, false)
} | go | func ReadJSON(filePath string) GossConfig {
file, err := ioutil.ReadFile(filePath)
if err != nil {
fmt.Printf("File error: %v\n", err)
os.Exit(1)
}
return ReadJSONData(file, false)
} | [
"func",
"ReadJSON",
"(",
"filePath",
"string",
")",
"GossConfig",
"{",
"file",
",",
"err",
":=",
"ioutil",
".",
"ReadFile",
"(",
"filePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n\n",
"return",
"ReadJSONData",
"(",
"file",
",",
"false",
")",
"\n",
"}"
] | // Reads json file returning GossConfig | [
"Reads",
"json",
"file",
"returning",
"GossConfig"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/store.go#L56-L64 | train |
aelsabbahy/goss | store.go | ReadJSONData | func ReadJSONData(data []byte, detectFormat bool) GossConfig {
if TemplateFilter != nil {
data = TemplateFilter(data)
if debug {
fmt.Println("DEBUG: file after text/template render")
fmt.Println(string(data))
}
}
format := OutStoreFormat
if detectFormat == true {
format = getStoreFormatFromData(data)
}
gossConfig := NewGossConfig()
// Horrible, but will do for now
if err := unmarshal(data, gossConfig, format); err != nil {
// FIXME: really dude.. this is so ugly
fmt.Printf("Error: %v\n", err)
os.Exit(1)
}
return *gossConfig
} | go | func ReadJSONData(data []byte, detectFormat bool) GossConfig {
if TemplateFilter != nil {
data = TemplateFilter(data)
if debug {
fmt.Println("DEBUG: file after text/template render")
fmt.Println(string(data))
}
}
format := OutStoreFormat
if detectFormat == true {
format = getStoreFormatFromData(data)
}
gossConfig := NewGossConfig()
// Horrible, but will do for now
if err := unmarshal(data, gossConfig, format); err != nil {
// FIXME: really dude.. this is so ugly
fmt.Printf("Error: %v\n", err)
os.Exit(1)
}
return *gossConfig
} | [
"func",
"ReadJSONData",
"(",
"data",
"[",
"]",
"byte",
",",
"detectFormat",
"bool",
")",
"GossConfig",
"{",
"if",
"TemplateFilter",
"!=",
"nil",
"{",
"data",
"=",
"TemplateFilter",
"(",
"data",
")",
"\n",
"if",
"debug",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"string",
"(",
"data",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"format",
":=",
"OutStoreFormat",
"\n",
"if",
"detectFormat",
"==",
"true",
"{",
"format",
"=",
"getStoreFormatFromData",
"(",
"data",
")",
"\n",
"}",
"\n",
"gossConfig",
":=",
"NewGossConfig",
"(",
")",
"\n",
"// Horrible, but will do for now",
"if",
"err",
":=",
"unmarshal",
"(",
"data",
",",
"gossConfig",
",",
"format",
")",
";",
"err",
"!=",
"nil",
"{",
"// FIXME: really dude.. this is so ugly",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"os",
".",
"Exit",
"(",
"1",
")",
"\n",
"}",
"\n",
"return",
"*",
"gossConfig",
"\n",
"}"
] | // Reads json byte array returning GossConfig | [
"Reads",
"json",
"byte",
"array",
"returning",
"GossConfig"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/store.go#L96-L116 | train |
aelsabbahy/goss | store.go | RenderJSON | func RenderJSON(c *cli.Context) string {
filePath := c.GlobalString("gossfile")
varsFile := c.GlobalString("vars")
debug = c.Bool("debug")
TemplateFilter = NewTemplateFilter(varsFile)
path := filepath.Dir(filePath)
OutStoreFormat = getStoreFormatFromFileName(filePath)
gossConfig := mergeJSONData(ReadJSON(filePath), 0, path)
b, err := marshal(gossConfig)
if err != nil {
log.Fatalf("Error rendering: %v\n", err)
}
return string(b)
} | go | func RenderJSON(c *cli.Context) string {
filePath := c.GlobalString("gossfile")
varsFile := c.GlobalString("vars")
debug = c.Bool("debug")
TemplateFilter = NewTemplateFilter(varsFile)
path := filepath.Dir(filePath)
OutStoreFormat = getStoreFormatFromFileName(filePath)
gossConfig := mergeJSONData(ReadJSON(filePath), 0, path)
b, err := marshal(gossConfig)
if err != nil {
log.Fatalf("Error rendering: %v\n", err)
}
return string(b)
} | [
"func",
"RenderJSON",
"(",
"c",
"*",
"cli",
".",
"Context",
")",
"string",
"{",
"filePath",
":=",
"c",
".",
"GlobalString",
"(",
"\"",
"\"",
")",
"\n",
"varsFile",
":=",
"c",
".",
"GlobalString",
"(",
"\"",
"\"",
")",
"\n",
"debug",
"=",
"c",
".",
"Bool",
"(",
"\"",
"\"",
")",
"\n",
"TemplateFilter",
"=",
"NewTemplateFilter",
"(",
"varsFile",
")",
"\n",
"path",
":=",
"filepath",
".",
"Dir",
"(",
"filePath",
")",
"\n",
"OutStoreFormat",
"=",
"getStoreFormatFromFileName",
"(",
"filePath",
")",
"\n",
"gossConfig",
":=",
"mergeJSONData",
"(",
"ReadJSON",
"(",
"filePath",
")",
",",
"0",
",",
"path",
")",
"\n\n",
"b",
",",
"err",
":=",
"marshal",
"(",
"gossConfig",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"Fatalf",
"(",
"\"",
"\\n",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"string",
"(",
"b",
")",
"\n",
"}"
] | // Reads json file recursively returning string | [
"Reads",
"json",
"file",
"recursively",
"returning",
"string"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/store.go#L119-L133 | train |
aelsabbahy/goss | outputs/outputs.go | Outputers | func Outputers() []string {
outputersMu.Lock()
defer outputersMu.Unlock()
var list []string
for name := range outputers {
list = append(list, name)
}
sort.Strings(list)
return list
} | go | func Outputers() []string {
outputersMu.Lock()
defer outputersMu.Unlock()
var list []string
for name := range outputers {
list = append(list, name)
}
sort.Strings(list)
return list
} | [
"func",
"Outputers",
"(",
")",
"[",
"]",
"string",
"{",
"outputersMu",
".",
"Lock",
"(",
")",
"\n",
"defer",
"outputersMu",
".",
"Unlock",
"(",
")",
"\n",
"var",
"list",
"[",
"]",
"string",
"\n",
"for",
"name",
":=",
"range",
"outputers",
"{",
"list",
"=",
"append",
"(",
"list",
",",
"name",
")",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"list",
")",
"\n",
"return",
"list",
"\n",
"}"
] | // Outputers returns a sorted list of the names of the registered outputers. | [
"Outputers",
"returns",
"a",
"sorted",
"list",
"of",
"the",
"names",
"of",
"the",
"registered",
"outputers",
"."
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/outputs/outputs.go#L102-L111 | train |
aelsabbahy/goss | system/dns.go | LookupHost | func LookupHost(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
a, _ := LookupA(host, server, c, m)
aaaa, _ := LookupAAAA(host, server, c, m)
addrs = append(a, aaaa...)
return
} | go | func LookupHost(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
a, _ := LookupA(host, server, c, m)
aaaa, _ := LookupAAAA(host, server, c, m)
addrs = append(a, aaaa...)
return
} | [
"func",
"LookupHost",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"a",
",",
"_",
":=",
"LookupA",
"(",
"host",
",",
"server",
",",
"c",
",",
"m",
")",
"\n",
"aaaa",
",",
"_",
":=",
"LookupAAAA",
"(",
"host",
",",
"server",
",",
"c",
",",
"m",
")",
"\n",
"addrs",
"=",
"append",
"(",
"a",
",",
"aaaa",
"...",
")",
"\n\n",
"return",
"\n",
"}"
] | // A and AAAA record lookup - similar to net.LookupHost | [
"A",
"and",
"AAAA",
"record",
"lookup",
"-",
"similar",
"to",
"net",
".",
"LookupHost"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L162-L168 | train |
aelsabbahy/goss | system/dns.go | LookupCNAME | func LookupCNAME(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCNAME)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CNAME); ok {
addrs = append(addrs, t.Target)
}
}
return
} | go | func LookupCNAME(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCNAME)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CNAME); ok {
addrs = append(addrs, t.Target)
}
}
return
} | [
"func",
"LookupCNAME",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeCNAME",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"CNAME",
")",
";",
"ok",
"{",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"t",
".",
"Target",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // CNAME record lookup | [
"CNAME",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L205-L219 | train |
aelsabbahy/goss | system/dns.go | LookupMX | func LookupMX(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeMX)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.MX); ok {
mxstring := strconv.Itoa(int(t.Preference)) + " " + t.Mx
addrs = append(addrs, mxstring)
}
}
return
} | go | func LookupMX(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeMX)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.MX); ok {
mxstring := strconv.Itoa(int(t.Preference)) + " " + t.Mx
addrs = append(addrs, mxstring)
}
}
return
} | [
"func",
"LookupMX",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeMX",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"MX",
")",
";",
"ok",
"{",
"mxstring",
":=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"t",
".",
"Preference",
")",
")",
"+",
"\"",
"\"",
"+",
"t",
".",
"Mx",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"mxstring",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // MX record lookup | [
"MX",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L222-L237 | train |
aelsabbahy/goss | system/dns.go | LookupNS | func LookupNS(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeNS)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.NS); ok {
addrs = append(addrs, t.Ns)
}
}
return
} | go | func LookupNS(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeNS)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.NS); ok {
addrs = append(addrs, t.Ns)
}
}
return
} | [
"func",
"LookupNS",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeNS",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"NS",
")",
";",
"ok",
"{",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"t",
".",
"Ns",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // NS record lookup | [
"NS",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L240-L254 | train |
aelsabbahy/goss | system/dns.go | LookupSRV | func LookupSRV(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeSRV)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.SRV); ok {
prio := strconv.Itoa(int(t.Priority))
weight := strconv.Itoa(int(t.Weight))
port := strconv.Itoa(int(t.Port))
srvrec := strings.Join([]string{prio, weight, port, t.Target}, " ")
addrs = append(addrs, srvrec)
}
}
return
} | go | func LookupSRV(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeSRV)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.SRV); ok {
prio := strconv.Itoa(int(t.Priority))
weight := strconv.Itoa(int(t.Weight))
port := strconv.Itoa(int(t.Port))
srvrec := strings.Join([]string{prio, weight, port, t.Target}, " ")
addrs = append(addrs, srvrec)
}
}
return
} | [
"func",
"LookupSRV",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeSRV",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"SRV",
")",
";",
"ok",
"{",
"prio",
":=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"t",
".",
"Priority",
")",
")",
"\n",
"weight",
":=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"t",
".",
"Weight",
")",
")",
"\n",
"port",
":=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"t",
".",
"Port",
")",
")",
"\n",
"srvrec",
":=",
"strings",
".",
"Join",
"(",
"[",
"]",
"string",
"{",
"prio",
",",
"weight",
",",
"port",
",",
"t",
".",
"Target",
"}",
",",
"\"",
"\"",
")",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"srvrec",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // SRV record lookup | [
"SRV",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L257-L275 | train |
aelsabbahy/goss | system/dns.go | LookupTXT | func LookupTXT(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeTXT)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.TXT); ok {
addrs = append(addrs, t.Txt...)
}
}
return
} | go | func LookupTXT(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeTXT)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.TXT); ok {
addrs = append(addrs, t.Txt...)
}
}
return
} | [
"func",
"LookupTXT",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeTXT",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"TXT",
")",
";",
"ok",
"{",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"t",
".",
"Txt",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // TXT record lookup | [
"TXT",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L278-L292 | train |
aelsabbahy/goss | system/dns.go | LookupPTR | func LookupPTR(addr string, server string, c *dns.Client, m *dns.Msg) (name []string, err error) {
reverse, err := dns.ReverseAddr(addr)
if err != nil {
return nil, err
}
m.SetQuestion(reverse, dns.TypePTR)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
name = append(name, ans.(*dns.PTR).Ptr)
}
return
} | go | func LookupPTR(addr string, server string, c *dns.Client, m *dns.Msg) (name []string, err error) {
reverse, err := dns.ReverseAddr(addr)
if err != nil {
return nil, err
}
m.SetQuestion(reverse, dns.TypePTR)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
name = append(name, ans.(*dns.PTR).Ptr)
}
return
} | [
"func",
"LookupPTR",
"(",
"addr",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"name",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"reverse",
",",
"err",
":=",
"dns",
".",
"ReverseAddr",
"(",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"m",
".",
"SetQuestion",
"(",
"reverse",
",",
"dns",
".",
"TypePTR",
")",
"\n\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"name",
"=",
"append",
"(",
"name",
",",
"ans",
".",
"(",
"*",
"dns",
".",
"PTR",
")",
".",
"Ptr",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // PTR record lookup | [
"PTR",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L295-L314 | train |
aelsabbahy/goss | system/dns.go | LookupCAA | func LookupCAA(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCAA)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CAA); ok {
flag := strconv.Itoa(int(t.Flag))
caarec := strings.Join([]string{flag, t.Tag, t.Value}, " ")
addrs = append(addrs, caarec)
}
}
return
} | go | func LookupCAA(host string, server string, c *dns.Client, m *dns.Msg) (addrs []string, err error) {
m.SetQuestion(dns.Fqdn(host), dns.TypeCAA)
r, _, err := c.Exchange(m, net.JoinHostPort(server, "53"))
if err != nil {
return nil, err
}
for _, ans := range r.Answer {
if t, ok := ans.(*dns.CAA); ok {
flag := strconv.Itoa(int(t.Flag))
caarec := strings.Join([]string{flag, t.Tag, t.Value}, " ")
addrs = append(addrs, caarec)
}
}
return
} | [
"func",
"LookupCAA",
"(",
"host",
"string",
",",
"server",
"string",
",",
"c",
"*",
"dns",
".",
"Client",
",",
"m",
"*",
"dns",
".",
"Msg",
")",
"(",
"addrs",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"m",
".",
"SetQuestion",
"(",
"dns",
".",
"Fqdn",
"(",
"host",
")",
",",
"dns",
".",
"TypeCAA",
")",
"\n",
"r",
",",
"_",
",",
"err",
":=",
"c",
".",
"Exchange",
"(",
"m",
",",
"net",
".",
"JoinHostPort",
"(",
"server",
",",
"\"",
"\"",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"ans",
":=",
"range",
"r",
".",
"Answer",
"{",
"if",
"t",
",",
"ok",
":=",
"ans",
".",
"(",
"*",
"dns",
".",
"CAA",
")",
";",
"ok",
"{",
"flag",
":=",
"strconv",
".",
"Itoa",
"(",
"int",
"(",
"t",
".",
"Flag",
")",
")",
"\n",
"caarec",
":=",
"strings",
".",
"Join",
"(",
"[",
"]",
"string",
"{",
"flag",
",",
"t",
".",
"Tag",
",",
"t",
".",
"Value",
"}",
",",
"\"",
"\"",
")",
"\n",
"addrs",
"=",
"append",
"(",
"addrs",
",",
"caarec",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"\n",
"}"
] | // CAA record lookup | [
"CAA",
"record",
"lookup"
] | 9c0d41fbdc8280be6a917e951acaf48f1f5c1f07 | https://github.com/aelsabbahy/goss/blob/9c0d41fbdc8280be6a917e951acaf48f1f5c1f07/system/dns.go#L317-L333 | train |
ahmdrz/goinsta | timeline.go | Stories | func (time *Timeline) Stories() (*Tray, error) {
body, err := time.inst.sendSimpleRequest(urlStories)
if err == nil {
tray := &Tray{}
err = json.Unmarshal(body, tray)
if err != nil {
return nil, err
}
tray.set(time.inst, urlStories)
return tray, nil
}
return nil, err
} | go | func (time *Timeline) Stories() (*Tray, error) {
body, err := time.inst.sendSimpleRequest(urlStories)
if err == nil {
tray := &Tray{}
err = json.Unmarshal(body, tray)
if err != nil {
return nil, err
}
tray.set(time.inst, urlStories)
return tray, nil
}
return nil, err
} | [
"func",
"(",
"time",
"*",
"Timeline",
")",
"Stories",
"(",
")",
"(",
"*",
"Tray",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"time",
".",
"inst",
".",
"sendSimpleRequest",
"(",
"urlStories",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"tray",
":=",
"&",
"Tray",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"tray",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"tray",
".",
"set",
"(",
"time",
".",
"inst",
",",
"urlStories",
")",
"\n",
"return",
"tray",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] | // Stories returns slice of StoryMedia | [
"Stories",
"returns",
"slice",
"of",
"StoryMedia"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/timeline.go#L31-L43 | train |
ahmdrz/goinsta | goinsta.go | New | func New(username, password string) *Instagram {
// this call never returns error
jar, _ := cookiejar.New(nil)
inst := &Instagram{
user: username,
pass: password,
dID: generateDeviceID(
generateMD5Hash(username + password),
),
uuid: generateUUID(), // both uuid must be differents
pid: generateUUID(),
c: &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
},
Jar: jar,
},
}
inst.init()
return inst
} | go | func New(username, password string) *Instagram {
// this call never returns error
jar, _ := cookiejar.New(nil)
inst := &Instagram{
user: username,
pass: password,
dID: generateDeviceID(
generateMD5Hash(username + password),
),
uuid: generateUUID(), // both uuid must be differents
pid: generateUUID(),
c: &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
},
Jar: jar,
},
}
inst.init()
return inst
} | [
"func",
"New",
"(",
"username",
",",
"password",
"string",
")",
"*",
"Instagram",
"{",
"// this call never returns error",
"jar",
",",
"_",
":=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"inst",
":=",
"&",
"Instagram",
"{",
"user",
":",
"username",
",",
"pass",
":",
"password",
",",
"dID",
":",
"generateDeviceID",
"(",
"generateMD5Hash",
"(",
"username",
"+",
"password",
")",
",",
")",
",",
"uuid",
":",
"generateUUID",
"(",
")",
",",
"// both uuid must be differents",
"pid",
":",
"generateUUID",
"(",
")",
",",
"c",
":",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"Proxy",
":",
"http",
".",
"ProxyFromEnvironment",
",",
"}",
",",
"Jar",
":",
"jar",
",",
"}",
",",
"}",
"\n",
"inst",
".",
"init",
"(",
")",
"\n\n",
"return",
"inst",
"\n",
"}"
] | // New creates Instagram structure | [
"New",
"creates",
"Instagram",
"structure"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L96-L117 | train |
ahmdrz/goinsta | goinsta.go | SetProxy | func (inst *Instagram) SetProxy(url string, insecure bool) error {
uri, err := neturl.Parse(url)
if err == nil {
inst.c.Transport = &http.Transport{
Proxy: http.ProxyURL(uri),
TLSClientConfig: &tls.Config{
InsecureSkipVerify: insecure,
},
}
}
return err
} | go | func (inst *Instagram) SetProxy(url string, insecure bool) error {
uri, err := neturl.Parse(url)
if err == nil {
inst.c.Transport = &http.Transport{
Proxy: http.ProxyURL(uri),
TLSClientConfig: &tls.Config{
InsecureSkipVerify: insecure,
},
}
}
return err
} | [
"func",
"(",
"inst",
"*",
"Instagram",
")",
"SetProxy",
"(",
"url",
"string",
",",
"insecure",
"bool",
")",
"error",
"{",
"uri",
",",
"err",
":=",
"neturl",
".",
"Parse",
"(",
"url",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"inst",
".",
"c",
".",
"Transport",
"=",
"&",
"http",
".",
"Transport",
"{",
"Proxy",
":",
"http",
".",
"ProxyURL",
"(",
"uri",
")",
",",
"TLSClientConfig",
":",
"&",
"tls",
".",
"Config",
"{",
"InsecureSkipVerify",
":",
"insecure",
",",
"}",
",",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // SetProxy sets proxy for connection. | [
"SetProxy",
"sets",
"proxy",
"for",
"connection",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L131-L142 | train |
ahmdrz/goinsta | goinsta.go | ImportReader | 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 := &Instagram{
user: config.User,
dID: config.DeviceID,
uuid: config.UUID,
rankToken: config.RankToken,
token: config.Token,
pid: config.PhoneID,
c: &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
},
},
}
inst.c.Jar, err = cookiejar.New(nil)
if err != nil {
return inst, err
}
inst.c.Jar.SetCookies(url, config.Cookies)
inst.init()
inst.Account = &Account{inst: inst, ID: config.ID}
inst.Account.Sync()
return inst, nil
} | go | 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 := &Instagram{
user: config.User,
dID: config.DeviceID,
uuid: config.UUID,
rankToken: config.RankToken,
token: config.Token,
pid: config.PhoneID,
c: &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
},
},
}
inst.c.Jar, err = cookiejar.New(nil)
if err != nil {
return inst, err
}
inst.c.Jar.SetCookies(url, config.Cookies)
inst.init()
inst.Account = &Account{inst: inst, ID: config.ID}
inst.Account.Sync()
return inst, nil
} | [
"func",
"ImportReader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"*",
"Instagram",
",",
"error",
")",
"{",
"url",
",",
"err",
":=",
"neturl",
".",
"Parse",
"(",
"goInstaAPIUrl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"bytes",
",",
"err",
":=",
"ioutil",
".",
"ReadAll",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"config",
":=",
"ConfigFile",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"bytes",
",",
"&",
"config",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"inst",
":=",
"&",
"Instagram",
"{",
"user",
":",
"config",
".",
"User",
",",
"dID",
":",
"config",
".",
"DeviceID",
",",
"uuid",
":",
"config",
".",
"UUID",
",",
"rankToken",
":",
"config",
".",
"RankToken",
",",
"token",
":",
"config",
".",
"Token",
",",
"pid",
":",
"config",
".",
"PhoneID",
",",
"c",
":",
"&",
"http",
".",
"Client",
"{",
"Transport",
":",
"&",
"http",
".",
"Transport",
"{",
"Proxy",
":",
"http",
".",
"ProxyFromEnvironment",
",",
"}",
",",
"}",
",",
"}",
"\n",
"inst",
".",
"c",
".",
"Jar",
",",
"err",
"=",
"cookiejar",
".",
"New",
"(",
"nil",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"inst",
",",
"err",
"\n",
"}",
"\n",
"inst",
".",
"c",
".",
"Jar",
".",
"SetCookies",
"(",
"url",
",",
"config",
".",
"Cookies",
")",
"\n\n",
"inst",
".",
"init",
"(",
")",
"\n",
"inst",
".",
"Account",
"=",
"&",
"Account",
"{",
"inst",
":",
"inst",
",",
"ID",
":",
"config",
".",
"ID",
"}",
"\n",
"inst",
".",
"Account",
".",
"Sync",
"(",
")",
"\n\n",
"return",
"inst",
",",
"nil",
"\n",
"}"
] | // ImportReader imports instagram configuration from io.Reader
//
// This function does not set proxy automatically. Use SetProxy after this call. | [
"ImportReader",
"imports",
"instagram",
"configuration",
"from",
"io",
".",
"Reader",
"This",
"function",
"does",
"not",
"set",
"proxy",
"automatically",
".",
"Use",
"SetProxy",
"after",
"this",
"call",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L211-L251 | train |
ahmdrz/goinsta | goinsta.go | Import | func Import(path string) (*Instagram, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return ImportReader(f)
} | go | func Import(path string) (*Instagram, error) {
f, err := os.Open(path)
if err != nil {
return nil, err
}
defer f.Close()
return ImportReader(f)
} | [
"func",
"Import",
"(",
"path",
"string",
")",
"(",
"*",
"Instagram",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"return",
"ImportReader",
"(",
"f",
")",
"\n",
"}"
] | // Import imports instagram configuration
//
// This function does not set proxy automatically. Use SetProxy after this call. | [
"Import",
"imports",
"instagram",
"configuration",
"This",
"function",
"does",
"not",
"set",
"proxy",
"automatically",
".",
"Use",
"SetProxy",
"after",
"this",
"call",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L256-L263 | train |
ahmdrz/goinsta | goinsta.go | Login | 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 != nil {
return err
}
result, err := json.Marshal(
map[string]interface{}{
"guid": inst.uuid,
"login_attempt_count": 0,
"_csrftoken": inst.token,
"device_id": inst.dID,
"adid": inst.adid,
"phone_id": inst.pid,
"username": inst.user,
"password": inst.pass,
"google_tokens": "[]",
},
)
if err != nil {
return err
}
body, err := inst.sendRequest(
&reqOptions{
Endpoint: urlLogin,
Query: generateSignature(b2s(result)),
IsPost: true,
Login: true,
},
)
if err != nil {
return err
}
inst.pass = ""
// getting account data
res := accountResp{}
err = json.Unmarshal(body, &res)
if err != nil {
return err
}
inst.Account = &res.Account
inst.Account.inst = inst
inst.rankToken = strconv.FormatInt(inst.Account.ID, 10) + "_" + inst.uuid
inst.zrToken()
return err
} | go | 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 != nil {
return err
}
result, err := json.Marshal(
map[string]interface{}{
"guid": inst.uuid,
"login_attempt_count": 0,
"_csrftoken": inst.token,
"device_id": inst.dID,
"adid": inst.adid,
"phone_id": inst.pid,
"username": inst.user,
"password": inst.pass,
"google_tokens": "[]",
},
)
if err != nil {
return err
}
body, err := inst.sendRequest(
&reqOptions{
Endpoint: urlLogin,
Query: generateSignature(b2s(result)),
IsPost: true,
Login: true,
},
)
if err != nil {
return err
}
inst.pass = ""
// getting account data
res := accountResp{}
err = json.Unmarshal(body, &res)
if err != nil {
return err
}
inst.Account = &res.Account
inst.Account.inst = inst
inst.rankToken = strconv.FormatInt(inst.Account.ID, 10) + "_" + inst.uuid
inst.zrToken()
return err
} | [
"func",
"(",
"inst",
"*",
"Instagram",
")",
"Login",
"(",
")",
"error",
"{",
"err",
":=",
"inst",
".",
"readMsisdnHeader",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"inst",
".",
"syncFeatures",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"inst",
".",
"zrToken",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"inst",
".",
"sendAdID",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"inst",
".",
"contactPrefill",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"result",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"inst",
".",
"uuid",
",",
"\"",
"\"",
":",
"0",
",",
"\"",
"\"",
":",
"inst",
".",
"token",
",",
"\"",
"\"",
":",
"inst",
".",
"dID",
",",
"\"",
"\"",
":",
"inst",
".",
"adid",
",",
"\"",
"\"",
":",
"inst",
".",
"pid",
",",
"\"",
"\"",
":",
"inst",
".",
"user",
",",
"\"",
"\"",
":",
"inst",
".",
"pass",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"inst",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlLogin",
",",
"Query",
":",
"generateSignature",
"(",
"b2s",
"(",
"result",
")",
")",
",",
"IsPost",
":",
"true",
",",
"Login",
":",
"true",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"inst",
".",
"pass",
"=",
"\"",
"\"",
"\n\n",
"// getting account data",
"res",
":=",
"accountResp",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"res",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"inst",
".",
"Account",
"=",
"&",
"res",
".",
"Account",
"\n",
"inst",
".",
"Account",
".",
"inst",
"=",
"inst",
"\n",
"inst",
".",
"rankToken",
"=",
"strconv",
".",
"FormatInt",
"(",
"inst",
".",
"Account",
".",
"ID",
",",
"10",
")",
"+",
"\"",
"\"",
"+",
"inst",
".",
"uuid",
"\n",
"inst",
".",
"zrToken",
"(",
")",
"\n\n",
"return",
"err",
"\n",
"}"
] | // Login performs instagram login.
//
// Password will be deleted after login | [
"Login",
"performs",
"instagram",
"login",
".",
"Password",
"will",
"be",
"deleted",
"after",
"login"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L347-L415 | train |
ahmdrz/goinsta | goinsta.go | Logout | func (inst *Instagram) Logout() error {
_, err := inst.sendSimpleRequest(urlLogout)
inst.c.Jar = nil
inst.c = nil
return err
} | go | func (inst *Instagram) Logout() error {
_, err := inst.sendSimpleRequest(urlLogout)
inst.c.Jar = nil
inst.c = nil
return err
} | [
"func",
"(",
"inst",
"*",
"Instagram",
")",
"Logout",
"(",
")",
"error",
"{",
"_",
",",
"err",
":=",
"inst",
".",
"sendSimpleRequest",
"(",
"urlLogout",
")",
"\n",
"inst",
".",
"c",
".",
"Jar",
"=",
"nil",
"\n",
"inst",
".",
"c",
"=",
"nil",
"\n",
"return",
"err",
"\n",
"}"
] | // Logout closes current session | [
"Logout",
"closes",
"current",
"session"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/goinsta.go#L418-L423 | train |
ahmdrz/goinsta | search.go | User | 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_token": insta.rankToken,
},
},
)
if err != nil {
return nil, err
}
res := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | go | 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_token": insta.rankToken,
},
},
)
if err != nil {
return nil, err
}
res := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | [
"func",
"(",
"search",
"*",
"Search",
")",
"User",
"(",
"user",
"string",
")",
"(",
"*",
"SearchResult",
",",
"error",
")",
"{",
"insta",
":=",
"search",
".",
"inst",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlSearchUser",
",",
"Query",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"goInstaSigKeyVersion",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"user",
",",
"\"",
"\"",
":",
"insta",
".",
"rankToken",
",",
"}",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"SearchResult",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"res",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // User search by username | [
"User",
"search",
"by",
"username"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/search.go#L73-L93 | train |
ahmdrz/goinsta | search.go | Tags | 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 nil, err
}
res := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | go | 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 nil, err
}
res := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | [
"func",
"(",
"search",
"*",
"Search",
")",
"Tags",
"(",
"tag",
"string",
")",
"(",
"*",
"SearchResult",
",",
"error",
")",
"{",
"insta",
":=",
"search",
".",
"inst",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlSearchTag",
",",
"Query",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"insta",
".",
"rankToken",
",",
"\"",
"\"",
":",
"tag",
",",
"}",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"SearchResult",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"res",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // Tags search by tag | [
"Tags",
"search",
"by",
"tag"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/search.go#L96-L115 | train |
ahmdrz/goinsta | search.go | Facebook | 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 := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | go | 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 := &SearchResult{}
err = json.Unmarshal(body, res)
return res, err
} | [
"func",
"(",
"search",
"*",
"Search",
")",
"Facebook",
"(",
"user",
"string",
")",
"(",
"*",
"SearchResult",
",",
"error",
")",
"{",
"insta",
":=",
"search",
".",
"inst",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlSearchFacebook",
",",
"Query",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"user",
",",
"\"",
"\"",
":",
"insta",
".",
"rankToken",
",",
"}",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"res",
":=",
"&",
"SearchResult",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"res",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // Facebook search by facebook user. | [
"Facebook",
"search",
"by",
"facebook",
"user",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/search.go#L151-L168 | train |
ahmdrz/goinsta | types.go | GetBest | 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 | 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
} | [
"func",
"(",
"img",
"Images",
")",
"GetBest",
"(",
")",
"string",
"{",
"best",
":=",
"\"",
"\"",
"\n",
"var",
"mh",
",",
"mw",
"int",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"img",
".",
"Versions",
"{",
"if",
"v",
".",
"Width",
">",
"mw",
"||",
"v",
".",
"Height",
">",
"mh",
"{",
"best",
"=",
"v",
".",
"URL",
"\n",
"mh",
",",
"mw",
"=",
"v",
".",
"Height",
",",
"v",
".",
"Width",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"best",
"\n",
"}"
] | // GetBest returns the URL of the image with the best quality. | [
"GetBest",
"returns",
"the",
"URL",
"of",
"the",
"image",
"with",
"the",
"best",
"quality",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/types.go#L149-L159 | train |
ahmdrz/goinsta | types.go | Unblock | func (b *BlockedUser) Unblock() error {
u := User{ID: b.UserID}
return u.Unblock()
} | go | func (b *BlockedUser) Unblock() error {
u := User{ID: b.UserID}
return u.Unblock()
} | [
"func",
"(",
"b",
"*",
"BlockedUser",
")",
"Unblock",
"(",
")",
"error",
"{",
"u",
":=",
"User",
"{",
"ID",
":",
"b",
".",
"UserID",
"}",
"\n",
"return",
"u",
".",
"Unblock",
"(",
")",
"\n",
"}"
] | // Unblock unblocks blocked user. | [
"Unblock",
"unblocks",
"blocked",
"user",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/types.go#L297-L300 | train |
ahmdrz/goinsta | utils.go | getImageDimensionFromReader | 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 | 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
} | [
"func",
"getImageDimensionFromReader",
"(",
"rdr",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"int",
",",
"error",
")",
"{",
"image",
",",
"_",
",",
"err",
":=",
"image",
".",
"DecodeConfig",
"(",
"rdr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"image",
".",
"Width",
",",
"image",
".",
"Height",
",",
"nil",
"\n",
"}"
] | // getImageDimensionFromReader return image dimension , types is .jpg and .png | [
"getImageDimensionFromReader",
"return",
"image",
"dimension",
"types",
"is",
".",
"jpg",
"and",
".",
"png"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/utils.go#L75-L81 | train |
ahmdrz/goinsta | account.go | Sync | 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.Unmarshal(body, &resp)
if err == nil {
*account = resp.Account
account.inst = insta
}
}
return err
} | go | 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.Unmarshal(body, &resp)
if err == nil {
*account = resp.Account
account.inst = insta
}
}
return err
} | [
"func",
"(",
"account",
"*",
"Account",
")",
"Sync",
"(",
")",
"error",
"{",
"insta",
":=",
"account",
".",
"inst",
"\n",
"data",
",",
"err",
":=",
"insta",
".",
"prepareData",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlCurrentUser",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"true",
",",
"}",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"resp",
":=",
"profResp",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"account",
"=",
"resp",
".",
"Account",
"\n",
"account",
".",
"inst",
"=",
"insta",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Sync updates account information | [
"Sync",
"updates",
"account",
"information"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/account.go#L74-L94 | train |
ahmdrz/goinsta | account.go | Saved | 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 | 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
} | [
"func",
"(",
"account",
"*",
"Account",
")",
"Saved",
"(",
")",
"(",
"*",
"SavedMedia",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"account",
".",
"inst",
".",
"sendSimpleRequest",
"(",
"urlUserTags",
",",
"account",
".",
"ID",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"media",
":=",
"&",
"SavedMedia",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"media",
")",
"\n",
"return",
"media",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] | // Saved returns saved media. | [
"Saved",
"returns",
"saved",
"media",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/account.go#L312-L320 | train |
ahmdrz/goinsta | account.go | SetBiography | 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,
Query: generateSignature(data),
IsPost: true,
},
)
if err == nil {
var resp struct {
User struct {
Pk int64 `json:"pk"`
Biography string `json:"biography"`
} `json:"user"`
Status string `json:"status"`
}
err = json.Unmarshal(body, &resp)
if err == nil {
account.Biography = resp.User.Biography
}
}
return err
} | go | 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,
Query: generateSignature(data),
IsPost: true,
},
)
if err == nil {
var resp struct {
User struct {
Pk int64 `json:"pk"`
Biography string `json:"biography"`
} `json:"user"`
Status string `json:"status"`
}
err = json.Unmarshal(body, &resp)
if err == nil {
account.Biography = resp.User.Biography
}
}
return err
} | [
"func",
"(",
"account",
"*",
"Account",
")",
"SetBiography",
"(",
"bio",
"string",
")",
"error",
"{",
"account",
".",
"edit",
"(",
")",
"// preparing to edit",
"\n",
"insta",
":=",
"account",
".",
"inst",
"\n",
"data",
",",
"err",
":=",
"insta",
".",
"prepareData",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"bio",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlSetBiography",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"true",
",",
"}",
",",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"resp",
"struct",
"{",
"User",
"struct",
"{",
"Pk",
"int64",
"`json:\"pk\"`",
"\n",
"Biography",
"string",
"`json:\"biography\"`",
"\n",
"}",
"`json:\"user\"`",
"\n",
"Status",
"string",
"`json:\"status\"`",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"account",
".",
"Biography",
"=",
"resp",
".",
"User",
".",
"Biography",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // SetBiography changes your Instagram's biography.
//
// This function updates current Account information. | [
"SetBiography",
"changes",
"your",
"Instagram",
"s",
"biography",
".",
"This",
"function",
"updates",
"current",
"Account",
"information",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/account.go#L350-L383 | train |
ahmdrz/goinsta | account.go | Liked | func (account *Account) Liked() *FeedMedia {
insta := account.inst
media := &FeedMedia{}
media.inst = insta
media.endpoint = urlFeedLiked
return media
} | go | func (account *Account) Liked() *FeedMedia {
insta := account.inst
media := &FeedMedia{}
media.inst = insta
media.endpoint = urlFeedLiked
return media
} | [
"func",
"(",
"account",
"*",
"Account",
")",
"Liked",
"(",
")",
"*",
"FeedMedia",
"{",
"insta",
":=",
"account",
".",
"inst",
"\n\n",
"media",
":=",
"&",
"FeedMedia",
"{",
"}",
"\n",
"media",
".",
"inst",
"=",
"insta",
"\n",
"media",
".",
"endpoint",
"=",
"urlFeedLiked",
"\n",
"return",
"media",
"\n",
"}"
] | // Liked are liked publications | [
"Liked",
"are",
"liked",
"publications"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/account.go#L386-L393 | train |
ahmdrz/goinsta | account.go | PendingFollowRequests | 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
Status string `json:"status"`
}
err = json.Unmarshal(resp, &result)
if err != nil {
return nil, err
}
if result.Status != "ok" {
return nil, fmt.Errorf("bad status: %s", result.Status)
}
return result.Users, nil
} | go | 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
Status string `json:"status"`
}
err = json.Unmarshal(resp, &result)
if err != nil {
return nil, err
}
if result.Status != "ok" {
return nil, fmt.Errorf("bad status: %s", result.Status)
}
return result.Users, nil
} | [
"func",
"(",
"account",
"*",
"Account",
")",
"PendingFollowRequests",
"(",
")",
"(",
"[",
"]",
"User",
",",
"error",
")",
"{",
"insta",
":=",
"account",
".",
"inst",
"\n",
"resp",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlFriendshipPending",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"var",
"result",
"struct",
"{",
"Users",
"[",
"]",
"User",
"`json:\"users\"`",
"\n",
"// TODO: pagination",
"// TODO: SuggestedUsers",
"Status",
"string",
"`json:\"status\"`",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"resp",
",",
"&",
"result",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"result",
".",
"Status",
"!=",
"\"",
"\"",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"result",
".",
"Status",
")",
"\n",
"}",
"\n\n",
"return",
"result",
".",
"Users",
",",
"nil",
"\n",
"}"
] | // PendingFollowRequests returns pending follow requests. | [
"PendingFollowRequests",
"returns",
"pending",
"follow",
"requests",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/account.go#L396-L422 | train |
ahmdrz/goinsta | feeds.go | LocationID | 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 != nil {
return nil, err
}
res := &FeedLocation{}
err = json.Unmarshal(body, res)
return res, err
} | go | 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 != nil {
return nil, err
}
res := &FeedLocation{}
err = json.Unmarshal(body, res)
return res, err
} | [
"func",
"(",
"feed",
"*",
"Feed",
")",
"LocationID",
"(",
"locationID",
"int64",
")",
"(",
"*",
"FeedLocation",
",",
"error",
")",
"{",
"insta",
":=",
"feed",
".",
"inst",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"fmt",
".",
"Sprintf",
"(",
"urlFeedLocationID",
",",
"locationID",
")",
",",
"Query",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"\"",
"\"",
":",
"insta",
".",
"rankToken",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"res",
":=",
"&",
"FeedLocation",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"res",
")",
"\n",
"return",
"res",
",",
"err",
"\n",
"}"
] | // Feed search by locationID | [
"Feed",
"search",
"by",
"locationID"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/feeds.go#L21-L39 | train |
ahmdrz/goinsta | media.go | SyncLikers | 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 | 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
} | [
"func",
"(",
"item",
"*",
"Item",
")",
"SyncLikers",
"(",
")",
"error",
"{",
"resp",
":=",
"respLikers",
"{",
"}",
"\n",
"insta",
":=",
"item",
".",
"media",
".",
"instagram",
"(",
")",
"\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendSimpleRequest",
"(",
"urlMediaLikers",
",",
"item",
".",
"ID",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"item",
".",
"Likers",
"=",
"resp",
".",
"Users",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // SyncLikers fetch new likers of a media
//
// This function updates Item.Likers value | [
"SyncLikers",
"fetch",
"new",
"likers",
"of",
"a",
"media",
"This",
"function",
"updates",
"Item",
".",
"Likers",
"value"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/media.go#L249-L261 | train |
ahmdrz/goinsta | media.go | ID | func (media *StoryMedia) ID() string {
switch id := media.Pk.(type) {
case int64:
return strconv.FormatInt(id, 10)
case string:
return id
}
return ""
} | go | func (media *StoryMedia) ID() string {
switch id := media.Pk.(type) {
case int64:
return strconv.FormatInt(id, 10)
case string:
return id
}
return ""
} | [
"func",
"(",
"media",
"*",
"StoryMedia",
")",
"ID",
"(",
")",
"string",
"{",
"switch",
"id",
":=",
"media",
".",
"Pk",
".",
"(",
"type",
")",
"{",
"case",
"int64",
":",
"return",
"strconv",
".",
"FormatInt",
"(",
"id",
",",
"10",
")",
"\n",
"case",
"string",
":",
"return",
"id",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ID returns Story id | [
"ID",
"returns",
"Story",
"id"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/media.go#L524-L532 | train |
ahmdrz/goinsta | media.go | Sync | 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"},
}
qjson, err := json.Marshal(query)
if err != nil {
return err
}
id := media.Pk.(string)
data, err := insta.prepareData(
map[string]interface{}{
"user_ids": []string{id},
"supported_capabilities_new": b2s(qjson),
},
)
if err != nil {
return err
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlReelMedia,
Query: generateSignature(data),
IsPost: true,
},
)
if err == nil {
resp := trayResp{}
err = json.Unmarshal(body, &resp)
if err == nil {
m, ok := resp.Reels[id]
if ok {
media.Items = m.Items
media.setValues()
return nil
}
err = fmt.Errorf("cannot find %s structure in response", id)
}
}
return err
} | go | 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"},
}
qjson, err := json.Marshal(query)
if err != nil {
return err
}
id := media.Pk.(string)
data, err := insta.prepareData(
map[string]interface{}{
"user_ids": []string{id},
"supported_capabilities_new": b2s(qjson),
},
)
if err != nil {
return err
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: urlReelMedia,
Query: generateSignature(data),
IsPost: true,
},
)
if err == nil {
resp := trayResp{}
err = json.Unmarshal(body, &resp)
if err == nil {
m, ok := resp.Reels[id]
if ok {
media.Items = m.Items
media.setValues()
return nil
}
err = fmt.Errorf("cannot find %s structure in response", id)
}
}
return err
} | [
"func",
"(",
"media",
"*",
"StoryMedia",
")",
"Sync",
"(",
")",
"error",
"{",
"insta",
":=",
"media",
".",
"inst",
"\n",
"query",
":=",
"[",
"]",
"trayRequest",
"{",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"}",
"\n",
"qjson",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"query",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"id",
":=",
"media",
".",
"Pk",
".",
"(",
"string",
")",
"\n",
"data",
",",
"err",
":=",
"insta",
".",
"prepareData",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"[",
"]",
"string",
"{",
"id",
"}",
",",
"\"",
"\"",
":",
"b2s",
"(",
"qjson",
")",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"urlReelMedia",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"true",
",",
"}",
",",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"resp",
":=",
"trayResp",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"m",
",",
"ok",
":=",
"resp",
".",
"Reels",
"[",
"id",
"]",
"\n",
"if",
"ok",
"{",
"media",
".",
"Items",
"=",
"m",
".",
"Items",
"\n",
"media",
".",
"setValues",
"(",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"id",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Sync function is used when Highlight must be sync.
// Highlight must be sync when User.Highlights does not return any object inside StoryMedia slice.
//
// This function does NOT update Stories items.
//
// This function updates StoryMedia.Items | [
"Sync",
"function",
"is",
"used",
"when",
"Highlight",
"must",
"be",
"sync",
".",
"Highlight",
"must",
"be",
"sync",
"when",
"User",
".",
"Highlights",
"does",
"not",
"return",
"any",
"object",
"inside",
"StoryMedia",
"slice",
".",
"This",
"function",
"does",
"NOT",
"update",
"Stories",
"items",
".",
"This",
"function",
"updates",
"StoryMedia",
".",
"Items"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/media.go#L589-L634 | train |
ahmdrz/goinsta | media.go | Sync | 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: generateSignature(data),
IsPost: false,
},
)
if err != nil {
return err
}
m := FeedMedia{}
err = json.Unmarshal(body, &m)
*media = m
media.endpoint = urlMediaInfo
media.inst = insta
media.NextID = id
media.setValues()
return err
} | go | 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: generateSignature(data),
IsPost: false,
},
)
if err != nil {
return err
}
m := FeedMedia{}
err = json.Unmarshal(body, &m)
*media = m
media.endpoint = urlMediaInfo
media.inst = insta
media.NextID = id
media.setValues()
return err
} | [
"func",
"(",
"media",
"*",
"FeedMedia",
")",
"Sync",
"(",
")",
"error",
"{",
"id",
":=",
"media",
".",
"ID",
"(",
")",
"\n",
"insta",
":=",
"media",
".",
"inst",
"\n\n",
"data",
",",
"err",
":=",
"insta",
".",
"prepareData",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
"{",
"\"",
"\"",
":",
"id",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"fmt",
".",
"Sprintf",
"(",
"urlMediaInfo",
",",
"id",
")",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"false",
",",
"}",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"m",
":=",
"FeedMedia",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"m",
")",
"\n",
"*",
"media",
"=",
"m",
"\n",
"media",
".",
"endpoint",
"=",
"urlMediaInfo",
"\n",
"media",
".",
"inst",
"=",
"insta",
"\n",
"media",
".",
"NextID",
"=",
"id",
"\n",
"media",
".",
"setValues",
"(",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Sync updates media values. | [
"Sync",
"updates",
"media",
"values",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/media.go#L717-L749 | train |
ahmdrz/goinsta | media.go | ID | 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 | 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 ""
} | [
"func",
"(",
"media",
"*",
"FeedMedia",
")",
"ID",
"(",
")",
"string",
"{",
"switch",
"s",
":=",
"media",
".",
"NextID",
".",
"(",
"type",
")",
"{",
"case",
"string",
":",
"return",
"s",
"\n",
"case",
"int64",
":",
"return",
"strconv",
".",
"FormatInt",
"(",
"s",
",",
"10",
")",
"\n",
"case",
"json",
".",
"Number",
":",
"return",
"string",
"(",
"s",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"\n",
"}"
] | // ID returns media id. | [
"ID",
"returns",
"media",
"id",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/media.go#L762-L772 | train |
ahmdrz/goinsta | inbox.go | Write | func (c *Conversation) Write(b []byte) (int, error) {
n := len(b)
return n, c.Send(b2s(b))
} | go | func (c *Conversation) Write(b []byte) (int, error) {
n := len(b)
return n, c.Send(b2s(b))
} | [
"func",
"(",
"c",
"*",
"Conversation",
")",
"Write",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"n",
":=",
"len",
"(",
"b",
")",
"\n",
"return",
"n",
",",
"c",
".",
"Send",
"(",
"b2s",
"(",
"b",
")",
")",
"\n",
"}"
] | // Write is like Send but being compatible with io.Writer. | [
"Write",
"is",
"like",
"Send",
"but",
"being",
"compatible",
"with",
"io",
".",
"Writer",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/inbox.go#L340-L343 | train |
ahmdrz/goinsta | comments.go | Next | 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.NextMaxID))
query["max_id"] = next
} else if comments.NextMinID != nil {
next, _ := strconv.Unquote(string(comments.NextMinID))
query["min_id"] = next
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: endpoint,
Connection: "keep-alive",
Query: query,
},
)
if err == nil {
c := Comments{}
err = json.Unmarshal(body, &c)
if err == nil {
*comments = c
comments.endpoint = endpoint
comments.item = item
if (!comments.HasMoreComments || comments.NextMaxID == nil) &&
(!comments.HasMoreHeadloadComments || comments.NextMinID == nil) {
comments.err = ErrNoMore
}
comments.setValues()
return true
}
}
comments.err = err
return false
} | go | 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.NextMaxID))
query["max_id"] = next
} else if comments.NextMinID != nil {
next, _ := strconv.Unquote(string(comments.NextMinID))
query["min_id"] = next
}
body, err := insta.sendRequest(
&reqOptions{
Endpoint: endpoint,
Connection: "keep-alive",
Query: query,
},
)
if err == nil {
c := Comments{}
err = json.Unmarshal(body, &c)
if err == nil {
*comments = c
comments.endpoint = endpoint
comments.item = item
if (!comments.HasMoreComments || comments.NextMaxID == nil) &&
(!comments.HasMoreHeadloadComments || comments.NextMinID == nil) {
comments.err = ErrNoMore
}
comments.setValues()
return true
}
}
comments.err = err
return false
} | [
"func",
"(",
"comments",
"*",
"Comments",
")",
"Next",
"(",
")",
"bool",
"{",
"if",
"comments",
".",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"item",
":=",
"comments",
".",
"item",
"\n",
"insta",
":=",
"item",
".",
"media",
".",
"instagram",
"(",
")",
"\n",
"endpoint",
":=",
"comments",
".",
"endpoint",
"\n",
"query",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"// \"can_support_threading\": \"true\",",
"}",
"\n",
"if",
"comments",
".",
"NextMaxID",
"!=",
"nil",
"{",
"next",
",",
"_",
":=",
"strconv",
".",
"Unquote",
"(",
"string",
"(",
"comments",
".",
"NextMaxID",
")",
")",
"\n",
"query",
"[",
"\"",
"\"",
"]",
"=",
"next",
"\n",
"}",
"else",
"if",
"comments",
".",
"NextMinID",
"!=",
"nil",
"{",
"next",
",",
"_",
":=",
"strconv",
".",
"Unquote",
"(",
"string",
"(",
"comments",
".",
"NextMinID",
")",
")",
"\n",
"query",
"[",
"\"",
"\"",
"]",
"=",
"next",
"\n",
"}",
"\n\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"endpoint",
",",
"Connection",
":",
"\"",
"\"",
",",
"Query",
":",
"query",
",",
"}",
",",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"c",
":=",
"Comments",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"c",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"*",
"comments",
"=",
"c",
"\n",
"comments",
".",
"endpoint",
"=",
"endpoint",
"\n",
"comments",
".",
"item",
"=",
"item",
"\n",
"if",
"(",
"!",
"comments",
".",
"HasMoreComments",
"||",
"comments",
".",
"NextMaxID",
"==",
"nil",
")",
"&&",
"(",
"!",
"comments",
".",
"HasMoreHeadloadComments",
"||",
"comments",
".",
"NextMinID",
"==",
"nil",
")",
"{",
"comments",
".",
"err",
"=",
"ErrNoMore",
"\n",
"}",
"\n",
"comments",
".",
"setValues",
"(",
")",
"\n",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"comments",
".",
"err",
"=",
"err",
"\n",
"return",
"false",
"\n",
"}"
] | // Next allows comment pagination.
//
// This function support concurrency methods to get comments using Last and Next ID
//
// New comments are stored in Comments.Items | [
"Next",
"allows",
"comment",
"pagination",
".",
"This",
"function",
"support",
"concurrency",
"methods",
"to",
"get",
"comments",
"using",
"Last",
"and",
"Next",
"ID",
"New",
"comments",
"are",
"stored",
"in",
"Comments",
".",
"Items"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/comments.go#L117-L160 | train |
ahmdrz/goinsta | comments.go | Del | 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: generateSignature(data),
IsPost: true,
},
)
return err
} | go | 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: generateSignature(data),
IsPost: true,
},
)
return err
} | [
"func",
"(",
"comments",
"*",
"Comments",
")",
"Del",
"(",
"comment",
"*",
"Comment",
")",
"error",
"{",
"insta",
":=",
"comments",
".",
"item",
".",
"media",
".",
"instagram",
"(",
")",
"\n\n",
"data",
",",
"err",
":=",
"insta",
".",
"prepareData",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"id",
":=",
"comment",
".",
"getid",
"(",
")",
"\n\n",
"_",
",",
"err",
"=",
"insta",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"fmt",
".",
"Sprintf",
"(",
"urlCommentDelete",
",",
"comments",
".",
"item",
".",
"ID",
",",
"id",
")",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"true",
",",
"}",
",",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Del deletes comment. | [
"Del",
"deletes",
"comment",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/comments.go#L230-L247 | train |
ahmdrz/goinsta | comments.go | Like | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Comment",
")",
"Like",
"(",
")",
"error",
"{",
"data",
",",
"err",
":=",
"c",
".",
"inst",
".",
"prepareData",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"_",
",",
"err",
"=",
"c",
".",
"inst",
".",
"sendRequest",
"(",
"&",
"reqOptions",
"{",
"Endpoint",
":",
"fmt",
".",
"Sprintf",
"(",
"urlCommentLike",
",",
"c",
".",
"getid",
"(",
")",
")",
",",
"Query",
":",
"generateSignature",
"(",
"data",
")",
",",
"IsPost",
":",
"true",
",",
"}",
",",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Like likes comment. | [
"Like",
"likes",
"comment",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/comments.go#L339-L353 | train |
ahmdrz/goinsta | hashtags.go | NewHashtag | func (inst *Instagram) NewHashtag(name string) *Hashtag {
return &Hashtag{
inst: inst,
Name: name,
}
} | go | func (inst *Instagram) NewHashtag(name string) *Hashtag {
return &Hashtag{
inst: inst,
Name: name,
}
} | [
"func",
"(",
"inst",
"*",
"Instagram",
")",
"NewHashtag",
"(",
"name",
"string",
")",
"*",
"Hashtag",
"{",
"return",
"&",
"Hashtag",
"{",
"inst",
":",
"inst",
",",
"Name",
":",
"name",
",",
"}",
"\n",
"}"
] | // NewHashtag returns initialised hashtag structure
// Name parameter is hashtag name | [
"NewHashtag",
"returns",
"initialised",
"hashtag",
"structure",
"Name",
"parameter",
"is",
"hashtag",
"name"
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/hashtags.go#L56-L61 | train |
ahmdrz/goinsta | hashtags.go | Sync | 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.Name = resp.Name
h.ID = resp.ID
h.MediaCount = resp.MediaCount
h.setValues()
}
}
return err
} | go | 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.Name = resp.Name
h.ID = resp.ID
h.MediaCount = resp.MediaCount
h.setValues()
}
}
return err
} | [
"func",
"(",
"h",
"*",
"Hashtag",
")",
"Sync",
"(",
")",
"error",
"{",
"insta",
":=",
"h",
".",
"inst",
"\n\n",
"body",
",",
"err",
":=",
"insta",
".",
"sendSimpleRequest",
"(",
"urlTagSync",
",",
"h",
".",
"Name",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"resp",
"struct",
"{",
"Name",
"string",
"`json:\"name\"`",
"\n",
"ID",
"int64",
"`json:\"id\"`",
"\n",
"MediaCount",
"int",
"`json:\"media_count\"`",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"h",
".",
"Name",
"=",
"resp",
".",
"Name",
"\n",
"h",
".",
"ID",
"=",
"resp",
".",
"ID",
"\n",
"h",
".",
"MediaCount",
"=",
"resp",
".",
"MediaCount",
"\n",
"h",
".",
"setValues",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] | // Sync updates Hashtag information preparing it to Next call. | [
"Sync",
"updates",
"Hashtag",
"information",
"preparing",
"it",
"to",
"Next",
"call",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/hashtags.go#L64-L83 | train |
ahmdrz/goinsta | hashtags.go | Stories | 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 | 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
} | [
"func",
"(",
"h",
"*",
"Hashtag",
")",
"Stories",
"(",
")",
"(",
"*",
"StoryMedia",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"h",
".",
"inst",
".",
"sendSimpleRequest",
"(",
"urlTagStories",
",",
"h",
".",
"Name",
",",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"var",
"resp",
"struct",
"{",
"Story",
"StoryMedia",
"`json:\"story\"`",
"\n",
"Status",
"string",
"`json:\"status\"`",
"\n",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"return",
"&",
"resp",
".",
"Story",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] | // Stories returns hashtag stories. | [
"Stories",
"returns",
"hashtag",
"stories",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/hashtags.go#L127-L140 | train |
ahmdrz/goinsta | profiles.go | Blocked | 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 | 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
} | [
"func",
"(",
"prof",
"*",
"Profiles",
")",
"Blocked",
"(",
")",
"(",
"[",
"]",
"BlockedUser",
",",
"error",
")",
"{",
"body",
",",
"err",
":=",
"prof",
".",
"inst",
".",
"sendSimpleRequest",
"(",
"urlBlockedList",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"resp",
":=",
"blockedListResp",
"{",
"}",
"\n",
"err",
"=",
"json",
".",
"Unmarshal",
"(",
"body",
",",
"&",
"resp",
")",
"\n",
"return",
"resp",
".",
"BlockedList",
",",
"err",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}"
] | // Blocked returns a list of blocked profiles. | [
"Blocked",
"returns",
"a",
"list",
"of",
"blocked",
"profiles",
"."
] | 86d8297fa4152941d864ca6d7d2e1f1f673708aa | https://github.com/ahmdrz/goinsta/blob/86d8297fa4152941d864ca6d7d2e1f1f673708aa/profiles.go#L61-L69 | train |
mailru/easyjson | opt/gotemplate_Uint64.go | MarshalJSON | func (v Uint64) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
v.MarshalEasyJSON(&w)
return w.Buffer.BuildBytes(), w.Error
} | go | func (v Uint64) MarshalJSON() ([]byte, error) {
w := jwriter.Writer{}
v.MarshalEasyJSON(&w)
return w.Buffer.BuildBytes(), w.Error
} | [
"func",
"(",
"v",
"Uint64",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"w",
":=",
"jwriter",
".",
"Writer",
"{",
"}",
"\n",
"v",
".",
"MarshalEasyJSON",
"(",
"&",
"w",
")",
"\n",
"return",
"w",
".",
"Buffer",
".",
"BuildBytes",
"(",
")",
",",
"w",
".",
"Error",
"\n",
"}"
] | // MarshalJSON implements a standard json marshaler interface. | [
"MarshalJSON",
"implements",
"a",
"standard",
"json",
"marshaler",
"interface",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/opt/gotemplate_Uint64.go#L54-L58 | train |
mailru/easyjson | opt/gotemplate_Uint64.go | UnmarshalJSON | func (v *Uint64) UnmarshalJSON(data []byte) error {
l := jlexer.Lexer{Data: data}
v.UnmarshalEasyJSON(&l)
return l.Error()
} | go | func (v *Uint64) UnmarshalJSON(data []byte) error {
l := jlexer.Lexer{Data: data}
v.UnmarshalEasyJSON(&l)
return l.Error()
} | [
"func",
"(",
"v",
"*",
"Uint64",
")",
"UnmarshalJSON",
"(",
"data",
"[",
"]",
"byte",
")",
"error",
"{",
"l",
":=",
"jlexer",
".",
"Lexer",
"{",
"Data",
":",
"data",
"}",
"\n",
"v",
".",
"UnmarshalEasyJSON",
"(",
"&",
"l",
")",
"\n",
"return",
"l",
".",
"Error",
"(",
")",
"\n",
"}"
] | // UnmarshalJSON implements a standard json unmarshaler interface. | [
"UnmarshalJSON",
"implements",
"a",
"standard",
"json",
"unmarshaler",
"interface",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/opt/gotemplate_Uint64.go#L61-L65 | train |
mailru/easyjson | gen/decoder.go | genTypeDecoder | 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)")
return nil
}
unmarshalerIface = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(unmarshalerIface) {
fmt.Fprintln(g.out, ws+"if data := in.Raw(); in.Ok() {")
fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalJSON(data) )")
fmt.Fprintln(g.out, ws+"}")
return nil
}
unmarshalerIface = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(unmarshalerIface) {
fmt.Fprintln(g.out, ws+"if data := in.UnsafeBytes(); in.Ok() {")
fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalText(data) )")
fmt.Fprintln(g.out, ws+"}")
return nil
}
err := g.genTypeDecoderNoCheck(t, out, tags, indent)
return err
} | go | 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)")
return nil
}
unmarshalerIface = reflect.TypeOf((*json.Unmarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(unmarshalerIface) {
fmt.Fprintln(g.out, ws+"if data := in.Raw(); in.Ok() {")
fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalJSON(data) )")
fmt.Fprintln(g.out, ws+"}")
return nil
}
unmarshalerIface = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(unmarshalerIface) {
fmt.Fprintln(g.out, ws+"if data := in.UnsafeBytes(); in.Ok() {")
fmt.Fprintln(g.out, ws+" in.AddError( ("+out+").UnmarshalText(data) )")
fmt.Fprintln(g.out, ws+"}")
return nil
}
err := g.genTypeDecoderNoCheck(t, out, tags, indent)
return err
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"genTypeDecoder",
"(",
"t",
"reflect",
".",
"Type",
",",
"out",
"string",
",",
"tags",
"fieldTags",
",",
"indent",
"int",
")",
"error",
"{",
"ws",
":=",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"indent",
")",
"\n\n",
"unmarshalerIface",
":=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"easyjson",
".",
"Unmarshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"unmarshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"out",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"unmarshalerIface",
"=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"json",
".",
"Unmarshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"unmarshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"out",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"unmarshalerIface",
"=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"encoding",
".",
"TextUnmarshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"unmarshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"out",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"g",
".",
"genTypeDecoderNoCheck",
"(",
"t",
",",
"out",
",",
"tags",
",",
"indent",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // genTypeDecoder generates decoding code for the type t, but uses unmarshaler interface if implemented by t. | [
"genTypeDecoder",
"generates",
"decoding",
"code",
"for",
"the",
"type",
"t",
"but",
"uses",
"unmarshaler",
"interface",
"if",
"implemented",
"by",
"t",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/decoder.go#L60-L87 | train |
mailru/easyjson | gen/decoder.go | hasCustomUnmarshaler | 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 | 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())
} | [
"func",
"hasCustomUnmarshaler",
"(",
"t",
"reflect",
".",
"Type",
")",
"bool",
"{",
"t",
"=",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
"\n",
"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",
"(",
")",
")",
"\n",
"}"
] | // returns true of the type t implements one of the custom unmarshaler interfaces | [
"returns",
"true",
"of",
"the",
"type",
"t",
"implements",
"one",
"of",
"the",
"custom",
"unmarshaler",
"interfaces"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/decoder.go#L90-L95 | train |
mailru/easyjson | opt/gotemplate_Float32.go | String | func (v Float32) String() string {
if !v.Defined {
return "<undefined>"
}
return fmt.Sprint(v.V)
} | go | func (v Float32) String() string {
if !v.Defined {
return "<undefined>"
}
return fmt.Sprint(v.V)
} | [
"func",
"(",
"v",
"Float32",
")",
"String",
"(",
")",
"string",
"{",
"if",
"!",
"v",
".",
"Defined",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprint",
"(",
"v",
".",
"V",
")",
"\n",
"}"
] | // String implements a stringer interface using fmt.Sprint for the value. | [
"String",
"implements",
"a",
"stringer",
"interface",
"using",
"fmt",
".",
"Sprint",
"for",
"the",
"value",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/opt/gotemplate_Float32.go#L74-L79 | train |
mailru/easyjson | gen/generator.go | NewGenerator | 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: make(map[reflect.Type]bool),
functionNames: make(map[string]reflect.Type),
}
// Use a file-unique prefix on all auxiliary funcs to avoid
// name clashes.
hash := fnv.New32()
hash.Write([]byte(filename))
ret.hashString = fmt.Sprintf("%x", hash.Sum32())
return ret
} | go | 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: make(map[reflect.Type]bool),
functionNames: make(map[string]reflect.Type),
}
// Use a file-unique prefix on all auxiliary funcs to avoid
// name clashes.
hash := fnv.New32()
hash.Write([]byte(filename))
ret.hashString = fmt.Sprintf("%x", hash.Sum32())
return ret
} | [
"func",
"NewGenerator",
"(",
"filename",
"string",
")",
"*",
"Generator",
"{",
"ret",
":=",
"&",
"Generator",
"{",
"imports",
":",
"map",
"[",
"string",
"]",
"string",
"{",
"pkgWriter",
":",
"\"",
"\"",
",",
"pkgLexer",
":",
"\"",
"\"",
",",
"pkgEasyJSON",
":",
"\"",
"\"",
",",
"\"",
"\"",
":",
"\"",
"\"",
",",
"}",
",",
"fieldNamer",
":",
"DefaultFieldNamer",
"{",
"}",
",",
"marshalers",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"bool",
")",
",",
"typesSeen",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"bool",
")",
",",
"functionNames",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"reflect",
".",
"Type",
")",
",",
"}",
"\n\n",
"// Use a file-unique prefix on all auxiliary funcs to avoid",
"// name clashes.",
"hash",
":=",
"fnv",
".",
"New32",
"(",
")",
"\n",
"hash",
".",
"Write",
"(",
"[",
"]",
"byte",
"(",
"filename",
")",
")",
"\n",
"ret",
".",
"hashString",
"=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"hash",
".",
"Sum32",
"(",
")",
")",
"\n\n",
"return",
"ret",
"\n",
"}"
] | // NewGenerator initializes and returns a Generator. | [
"NewGenerator",
"initializes",
"and",
"returns",
"a",
"Generator",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L59-L80 | train |
mailru/easyjson | gen/generator.go | SetPkg | func (g *Generator) SetPkg(name, path string) {
g.pkgName = name
g.pkgPath = path
} | go | func (g *Generator) SetPkg(name, path string) {
g.pkgName = name
g.pkgPath = path
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"SetPkg",
"(",
"name",
",",
"path",
"string",
")",
"{",
"g",
".",
"pkgName",
"=",
"name",
"\n",
"g",
".",
"pkgPath",
"=",
"path",
"\n",
"}"
] | // SetPkg sets the name and path of output package. | [
"SetPkg",
"sets",
"the",
"name",
"and",
"path",
"of",
"output",
"package",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L83-L86 | train |
mailru/easyjson | gen/generator.go | printHeader | 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 []string
for path, alias := range g.imports {
aliases = append(aliases, alias)
byAlias[alias] = path
}
sort.Strings(aliases)
fmt.Println("import (")
for _, alias := range aliases {
fmt.Printf(" %s %q\n", alias, byAlias[alias])
}
fmt.Println(")")
fmt.Println("")
fmt.Println("// suppress unused package warning")
fmt.Println("var (")
fmt.Println(" _ *json.RawMessage")
fmt.Println(" _ *jlexer.Lexer")
fmt.Println(" _ *jwriter.Writer")
fmt.Println(" _ easyjson.Marshaler")
fmt.Println(")")
fmt.Println()
} | go | 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 []string
for path, alias := range g.imports {
aliases = append(aliases, alias)
byAlias[alias] = path
}
sort.Strings(aliases)
fmt.Println("import (")
for _, alias := range aliases {
fmt.Printf(" %s %q\n", alias, byAlias[alias])
}
fmt.Println(")")
fmt.Println("")
fmt.Println("// suppress unused package warning")
fmt.Println("var (")
fmt.Println(" _ *json.RawMessage")
fmt.Println(" _ *jlexer.Lexer")
fmt.Println(" _ *jwriter.Writer")
fmt.Println(" _ easyjson.Marshaler")
fmt.Println(")")
fmt.Println()
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"printHeader",
"(",
")",
"{",
"if",
"g",
".",
"buildTags",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"g",
".",
"buildTags",
")",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"g",
".",
"pkgName",
")",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n\n",
"byAlias",
":=",
"map",
"[",
"string",
"]",
"string",
"{",
"}",
"\n",
"var",
"aliases",
"[",
"]",
"string",
"\n",
"for",
"path",
",",
"alias",
":=",
"range",
"g",
".",
"imports",
"{",
"aliases",
"=",
"append",
"(",
"aliases",
",",
"alias",
")",
"\n",
"byAlias",
"[",
"alias",
"]",
"=",
"path",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"aliases",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"alias",
":=",
"range",
"aliases",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"alias",
",",
"byAlias",
"[",
"alias",
"]",
")",
"\n",
"}",
"\n\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"}"
] | // printHeader prints package declaration and imports. | [
"printHeader",
"prints",
"package",
"declaration",
"and",
"imports",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L149-L183 | train |
mailru/easyjson | gen/generator.go | Run | 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 != nil {
return err
}
if !g.marshalers[t] {
continue
}
if err := g.genStructMarshaler(t); err != nil {
return err
}
if err := g.genStructUnmarshaler(t); err != nil {
return err
}
}
g.printHeader()
_, err := out.Write(g.out.Bytes())
return err
} | go | 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 != nil {
return err
}
if !g.marshalers[t] {
continue
}
if err := g.genStructMarshaler(t); err != nil {
return err
}
if err := g.genStructUnmarshaler(t); err != nil {
return err
}
}
g.printHeader()
_, err := out.Write(g.out.Bytes())
return err
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"Run",
"(",
"out",
"io",
".",
"Writer",
")",
"error",
"{",
"g",
".",
"out",
"=",
"&",
"bytes",
".",
"Buffer",
"{",
"}",
"\n\n",
"for",
"len",
"(",
"g",
".",
"typesUnseen",
")",
">",
"0",
"{",
"t",
":=",
"g",
".",
"typesUnseen",
"[",
"len",
"(",
"g",
".",
"typesUnseen",
")",
"-",
"1",
"]",
"\n",
"g",
".",
"typesUnseen",
"=",
"g",
".",
"typesUnseen",
"[",
":",
"len",
"(",
"g",
".",
"typesUnseen",
")",
"-",
"1",
"]",
"\n",
"g",
".",
"typesSeen",
"[",
"t",
"]",
"=",
"true",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genDecoder",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"g",
".",
"genEncoder",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"g",
".",
"marshalers",
"[",
"t",
"]",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genStructMarshaler",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"g",
".",
"genStructUnmarshaler",
"(",
"t",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n",
"g",
".",
"printHeader",
"(",
")",
"\n",
"_",
",",
"err",
":=",
"out",
".",
"Write",
"(",
"g",
".",
"out",
".",
"Bytes",
"(",
")",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // Run runs the generator and outputs generated code to out. | [
"Run",
"runs",
"the",
"generator",
"and",
"outputs",
"generated",
"code",
"to",
"out",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L186-L215 | train |
mailru/easyjson | gen/generator.go | fixPkgPathVendoring | func fixPkgPathVendoring(pkgPath string) string {
const vendor = "/vendor/"
if i := strings.LastIndex(pkgPath, vendor); i != -1 {
return pkgPath[i+len(vendor):]
}
return pkgPath
} | go | func fixPkgPathVendoring(pkgPath string) string {
const vendor = "/vendor/"
if i := strings.LastIndex(pkgPath, vendor); i != -1 {
return pkgPath[i+len(vendor):]
}
return pkgPath
} | [
"func",
"fixPkgPathVendoring",
"(",
"pkgPath",
"string",
")",
"string",
"{",
"const",
"vendor",
"=",
"\"",
"\"",
"\n",
"if",
"i",
":=",
"strings",
".",
"LastIndex",
"(",
"pkgPath",
",",
"vendor",
")",
";",
"i",
"!=",
"-",
"1",
"{",
"return",
"pkgPath",
"[",
"i",
"+",
"len",
"(",
"vendor",
")",
":",
"]",
"\n",
"}",
"\n",
"return",
"pkgPath",
"\n",
"}"
] | // fixes vendored paths | [
"fixes",
"vendored",
"paths"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L218-L224 | train |
mailru/easyjson | gen/generator.go | pkgAlias | 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 {
if v == alias {
exists = true
break
}
}
if !exists {
g.imports[pkgPath] = alias
return alias
}
}
} | go | 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 {
if v == alias {
exists = true
break
}
}
if !exists {
g.imports[pkgPath] = alias
return alias
}
}
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"pkgAlias",
"(",
"pkgPath",
"string",
")",
"string",
"{",
"pkgPath",
"=",
"fixPkgPathVendoring",
"(",
"pkgPath",
")",
"\n",
"if",
"alias",
":=",
"g",
".",
"imports",
"[",
"pkgPath",
"]",
";",
"alias",
"!=",
"\"",
"\"",
"{",
"return",
"alias",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
";",
"i",
"++",
"{",
"alias",
":=",
"fixAliasName",
"(",
"path",
".",
"Base",
"(",
"pkgPath",
")",
")",
"\n",
"if",
"i",
">",
"0",
"{",
"alias",
"+=",
"fmt",
".",
"Sprint",
"(",
"i",
")",
"\n",
"}",
"\n\n",
"exists",
":=",
"false",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"g",
".",
"imports",
"{",
"if",
"v",
"==",
"alias",
"{",
"exists",
"=",
"true",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"exists",
"{",
"g",
".",
"imports",
"[",
"pkgPath",
"]",
"=",
"alias",
"\n",
"return",
"alias",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] | // pkgAlias creates and returns and import alias for a given package. | [
"pkgAlias",
"creates",
"and",
"returns",
"and",
"import",
"alias",
"for",
"a",
"given",
"package",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L241-L266 | train |
mailru/easyjson | gen/generator.go | getType | 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:
return "map[" + g.getType(t.Key()) + "]" + g.getType(t.Elem())
}
}
if t.Name() == "" || t.PkgPath() == "" {
if t.Kind() == reflect.Struct {
// the fields of an anonymous struct can have named types,
// and t.String() will not be sufficient because it does not
// remove the package name when it matches g.pkgPath.
// so we convert by hand
nf := t.NumField()
lines := make([]string, 0, nf)
for i := 0; i < nf; i++ {
f := t.Field(i)
var line string
if !f.Anonymous {
line = f.Name + " "
} // else the field is anonymous (an embedded type)
line += g.getType(f.Type)
t := f.Tag
if t != "" {
line += " " + escapeTag(t)
}
lines = append(lines, line)
}
return strings.Join([]string{"struct { ", strings.Join(lines, "; "), " }"}, "")
}
return t.String()
} else if t.PkgPath() == g.pkgPath {
return t.Name()
}
return g.pkgAlias(t.PkgPath()) + "." + t.Name()
} | go | 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:
return "map[" + g.getType(t.Key()) + "]" + g.getType(t.Elem())
}
}
if t.Name() == "" || t.PkgPath() == "" {
if t.Kind() == reflect.Struct {
// the fields of an anonymous struct can have named types,
// and t.String() will not be sufficient because it does not
// remove the package name when it matches g.pkgPath.
// so we convert by hand
nf := t.NumField()
lines := make([]string, 0, nf)
for i := 0; i < nf; i++ {
f := t.Field(i)
var line string
if !f.Anonymous {
line = f.Name + " "
} // else the field is anonymous (an embedded type)
line += g.getType(f.Type)
t := f.Tag
if t != "" {
line += " " + escapeTag(t)
}
lines = append(lines, line)
}
return strings.Join([]string{"struct { ", strings.Join(lines, "; "), " }"}, "")
}
return t.String()
} else if t.PkgPath() == g.pkgPath {
return t.Name()
}
return g.pkgAlias(t.PkgPath()) + "." + t.Name()
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"getType",
"(",
"t",
"reflect",
".",
"Type",
")",
"string",
"{",
"if",
"t",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"switch",
"t",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Ptr",
":",
"return",
"\"",
"\"",
"+",
"g",
".",
"getType",
"(",
"t",
".",
"Elem",
"(",
")",
")",
"\n",
"case",
"reflect",
".",
"Slice",
":",
"return",
"\"",
"\"",
"+",
"g",
".",
"getType",
"(",
"t",
".",
"Elem",
"(",
")",
")",
"\n",
"case",
"reflect",
".",
"Array",
":",
"return",
"\"",
"\"",
"+",
"strconv",
".",
"Itoa",
"(",
"t",
".",
"Len",
"(",
")",
")",
"+",
"\"",
"\"",
"+",
"g",
".",
"getType",
"(",
"t",
".",
"Elem",
"(",
")",
")",
"\n",
"case",
"reflect",
".",
"Map",
":",
"return",
"\"",
"\"",
"+",
"g",
".",
"getType",
"(",
"t",
".",
"Key",
"(",
")",
")",
"+",
"\"",
"\"",
"+",
"g",
".",
"getType",
"(",
"t",
".",
"Elem",
"(",
")",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"||",
"t",
".",
"PkgPath",
"(",
")",
"==",
"\"",
"\"",
"{",
"if",
"t",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"{",
"// the fields of an anonymous struct can have named types,",
"// and t.String() will not be sufficient because it does not",
"// remove the package name when it matches g.pkgPath.",
"// so we convert by hand",
"nf",
":=",
"t",
".",
"NumField",
"(",
")",
"\n",
"lines",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"nf",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"nf",
";",
"i",
"++",
"{",
"f",
":=",
"t",
".",
"Field",
"(",
"i",
")",
"\n",
"var",
"line",
"string",
"\n",
"if",
"!",
"f",
".",
"Anonymous",
"{",
"line",
"=",
"f",
".",
"Name",
"+",
"\"",
"\"",
"\n",
"}",
"// else the field is anonymous (an embedded type)",
"\n",
"line",
"+=",
"g",
".",
"getType",
"(",
"f",
".",
"Type",
")",
"\n",
"t",
":=",
"f",
".",
"Tag",
"\n",
"if",
"t",
"!=",
"\"",
"\"",
"{",
"line",
"+=",
"\"",
"\"",
"+",
"escapeTag",
"(",
"t",
")",
"\n",
"}",
"\n",
"lines",
"=",
"append",
"(",
"lines",
",",
"line",
")",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Join",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"strings",
".",
"Join",
"(",
"lines",
",",
"\"",
"\"",
")",
",",
"\"",
"\"",
"}",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"t",
".",
"String",
"(",
")",
"\n",
"}",
"else",
"if",
"t",
".",
"PkgPath",
"(",
")",
"==",
"g",
".",
"pkgPath",
"{",
"return",
"t",
".",
"Name",
"(",
")",
"\n",
"}",
"\n",
"return",
"g",
".",
"pkgAlias",
"(",
"t",
".",
"PkgPath",
"(",
")",
")",
"+",
"\"",
"\"",
"+",
"t",
".",
"Name",
"(",
")",
"\n",
"}"
] | // getType return the textual type name of given type that can be used in generated code. | [
"getType",
"return",
"the",
"textual",
"type",
"name",
"of",
"given",
"type",
"that",
"can",
"be",
"used",
"in",
"generated",
"code",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L269-L311 | train |
mailru/easyjson | gen/generator.go | escapeTag | 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 | 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 + "`"
} | [
"func",
"escapeTag",
"(",
"tag",
"reflect",
".",
"StructTag",
")",
"string",
"{",
"t",
":=",
"string",
"(",
"tag",
")",
"\n",
"if",
"strings",
".",
"ContainsRune",
"(",
"t",
",",
"'`'",
")",
"{",
"// there are ` in the string; we can't use ` to enclose the string",
"return",
"strconv",
".",
"Quote",
"(",
"t",
")",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"+",
"t",
"+",
"\"",
"\"",
"\n",
"}"
] | // escape a struct field tag string back to source code | [
"escape",
"a",
"struct",
"field",
"tag",
"string",
"back",
"to",
"source",
"code"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L314-L321 | train |
mailru/easyjson | gen/generator.go | uniqueVarName | func (g *Generator) uniqueVarName() string {
g.varCounter++
return fmt.Sprint("v", g.varCounter)
} | go | func (g *Generator) uniqueVarName() string {
g.varCounter++
return fmt.Sprint("v", g.varCounter)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"uniqueVarName",
"(",
")",
"string",
"{",
"g",
".",
"varCounter",
"++",
"\n",
"return",
"fmt",
".",
"Sprint",
"(",
"\"",
"\"",
",",
"g",
".",
"varCounter",
")",
"\n",
"}"
] | // uniqueVarName returns a file-unique name that can be used for generated variables. | [
"uniqueVarName",
"returns",
"a",
"file",
"-",
"unique",
"name",
"that",
"can",
"be",
"used",
"for",
"generated",
"variables",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L324-L327 | train |
mailru/easyjson | gen/generator.go | lowerFirst | 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 lowercase
*/
foundLower := false
for i := range s {
ch := s[i]
if isUpper(ch) {
switch {
case i == 0:
str += string(ch + 32)
case !foundLower: // Currently just a stream of capitals, eg JSONRESTS[erver]
if strlen > (i+1) && isLower(s[i+1]) {
// Next char is lower, keep this a capital
str += string(ch)
} else {
// Either at end of string or next char is capital
str += string(ch + 32)
}
default:
str += string(ch)
}
} else {
foundLower = true
str += string(ch)
}
}
return str
} | go | 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 lowercase
*/
foundLower := false
for i := range s {
ch := s[i]
if isUpper(ch) {
switch {
case i == 0:
str += string(ch + 32)
case !foundLower: // Currently just a stream of capitals, eg JSONRESTS[erver]
if strlen > (i+1) && isLower(s[i+1]) {
// Next char is lower, keep this a capital
str += string(ch)
} else {
// Either at end of string or next char is capital
str += string(ch + 32)
}
default:
str += string(ch)
}
} else {
foundLower = true
str += string(ch)
}
}
return str
} | [
"func",
"lowerFirst",
"(",
"s",
"string",
")",
"string",
"{",
"if",
"s",
"==",
"\"",
"\"",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"str",
":=",
"\"",
"\"",
"\n",
"strlen",
":=",
"len",
"(",
"s",
")",
"\n\n",
"/**\n\t Loop each char\n\t If is uppercase:\n\t If is first char, LOWER it\n\t If the following char is lower, LEAVE it\n\t If the following char is upper OR numeric, LOWER it\n\t If is the end of string, LEAVE it\n\t Else lowercase\n\t*/",
"foundLower",
":=",
"false",
"\n",
"for",
"i",
":=",
"range",
"s",
"{",
"ch",
":=",
"s",
"[",
"i",
"]",
"\n",
"if",
"isUpper",
"(",
"ch",
")",
"{",
"switch",
"{",
"case",
"i",
"==",
"0",
":",
"str",
"+=",
"string",
"(",
"ch",
"+",
"32",
")",
"\n",
"case",
"!",
"foundLower",
":",
"// Currently just a stream of capitals, eg JSONRESTS[erver]",
"if",
"strlen",
">",
"(",
"i",
"+",
"1",
")",
"&&",
"isLower",
"(",
"s",
"[",
"i",
"+",
"1",
"]",
")",
"{",
"// Next char is lower, keep this a capital",
"str",
"+=",
"string",
"(",
"ch",
")",
"\n",
"}",
"else",
"{",
"// Either at end of string or next char is capital",
"str",
"+=",
"string",
"(",
"ch",
"+",
"32",
")",
"\n",
"}",
"\n",
"default",
":",
"str",
"+=",
"string",
"(",
"ch",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"foundLower",
"=",
"true",
"\n",
"str",
"+=",
"string",
"(",
"ch",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"str",
"\n",
"}"
] | // convert HTTPRestClient to httpRestClient | [
"convert",
"HTTPRestClient",
"to",
"httpRestClient"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/generator.go#L408-L451 | train |
mailru/easyjson | gen/encoder.go | parseFieldTags | 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 = true
case s == "string":
ret.asString = true
case s == "required":
ret.required = true
}
}
return ret
} | go | 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 = true
case s == "string":
ret.asString = true
case s == "required":
ret.required = true
}
}
return ret
} | [
"func",
"parseFieldTags",
"(",
"f",
"reflect",
".",
"StructField",
")",
"fieldTags",
"{",
"var",
"ret",
"fieldTags",
"\n\n",
"for",
"i",
",",
"s",
":=",
"range",
"strings",
".",
"Split",
"(",
"f",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
",",
"\"",
"\"",
")",
"{",
"switch",
"{",
"case",
"i",
"==",
"0",
"&&",
"s",
"==",
"\"",
"\"",
":",
"ret",
".",
"omit",
"=",
"true",
"\n",
"case",
"i",
"==",
"0",
":",
"ret",
".",
"name",
"=",
"s",
"\n",
"case",
"s",
"==",
"\"",
"\"",
":",
"ret",
".",
"omitEmpty",
"=",
"true",
"\n",
"case",
"s",
"==",
"\"",
"\"",
":",
"ret",
".",
"noOmitEmpty",
"=",
"true",
"\n",
"case",
"s",
"==",
"\"",
"\"",
":",
"ret",
".",
"asString",
"=",
"true",
"\n",
"case",
"s",
"==",
"\"",
"\"",
":",
"ret",
".",
"required",
"=",
"true",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"ret",
"\n",
"}"
] | // parseFieldTags parses the json field tag into a structure. | [
"parseFieldTags",
"parses",
"the",
"json",
"field",
"tag",
"into",
"a",
"structure",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/encoder.go#L64-L85 | train |
mailru/easyjson | gen/encoder.go | genTypeEncoder | 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+").MarshalEasyJSON(out)")
return nil
}
marshalerIface = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(marshalerIface) {
fmt.Fprintln(g.out, ws+"out.Raw( ("+in+").MarshalJSON() )")
return nil
}
marshalerIface = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(marshalerIface) {
fmt.Fprintln(g.out, ws+"out.RawText( ("+in+").MarshalText() )")
return nil
}
err := g.genTypeEncoderNoCheck(t, in, tags, indent, assumeNonEmpty)
return err
} | go | 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+").MarshalEasyJSON(out)")
return nil
}
marshalerIface = reflect.TypeOf((*json.Marshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(marshalerIface) {
fmt.Fprintln(g.out, ws+"out.Raw( ("+in+").MarshalJSON() )")
return nil
}
marshalerIface = reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()
if reflect.PtrTo(t).Implements(marshalerIface) {
fmt.Fprintln(g.out, ws+"out.RawText( ("+in+").MarshalText() )")
return nil
}
err := g.genTypeEncoderNoCheck(t, in, tags, indent, assumeNonEmpty)
return err
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"genTypeEncoder",
"(",
"t",
"reflect",
".",
"Type",
",",
"in",
"string",
",",
"tags",
"fieldTags",
",",
"indent",
"int",
",",
"assumeNonEmpty",
"bool",
")",
"error",
"{",
"ws",
":=",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"indent",
")",
"\n\n",
"marshalerIface",
":=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"easyjson",
".",
"Marshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"marshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"marshalerIface",
"=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"json",
".",
"Marshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"marshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"marshalerIface",
"=",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"encoding",
".",
"TextMarshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
"\n",
"if",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
".",
"Implements",
"(",
"marshalerIface",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
":=",
"g",
".",
"genTypeEncoderNoCheck",
"(",
"t",
",",
"in",
",",
"tags",
",",
"indent",
",",
"assumeNonEmpty",
")",
"\n",
"return",
"err",
"\n",
"}"
] | // genTypeEncoder generates code that encodes in of type t into the writer, but uses marshaler interface if implemented by t. | [
"genTypeEncoder",
"generates",
"code",
"that",
"encodes",
"in",
"of",
"type",
"t",
"into",
"the",
"writer",
"but",
"uses",
"marshaler",
"interface",
"if",
"implemented",
"by",
"t",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/encoder.go#L88-L111 | train |
mailru/easyjson | gen/encoder.go | hasCustomMarshaler | 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 | 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())
} | [
"func",
"hasCustomMarshaler",
"(",
"t",
"reflect",
".",
"Type",
")",
"bool",
"{",
"t",
"=",
"reflect",
".",
"PtrTo",
"(",
"t",
")",
"\n",
"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",
"(",
")",
")",
"\n",
"}"
] | // returns true of the type t implements one of the custom marshaler interfaces | [
"returns",
"true",
"of",
"the",
"type",
"t",
"implements",
"one",
"of",
"the",
"custom",
"marshaler",
"interfaces"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/encoder.go#L114-L119 | train |
mailru/easyjson | gen/encoder.go | genTypeEncoderNoCheck | 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.Fprintf(g.out, ws+enc+"\n", in)
return nil
} else if enc := primitiveEncoders[t.Kind()]; enc != "" {
fmt.Fprintf(g.out, ws+enc+"\n", in)
return nil
}
switch t.Kind() {
case reflect.Slice:
elem := t.Elem()
iVar := g.uniqueVarName()
vVar := g.uniqueVarName()
if t.Elem().Kind() == reflect.Uint8 && elem.Name() == "uint8" {
fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+")")
} else {
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilSliceAsEmpty) == 0 {")
fmt.Fprintln(g.out, ws+` out.RawString("null")`)
fmt.Fprintln(g.out, ws+"} else {")
} else {
fmt.Fprintln(g.out, ws+"{")
}
fmt.Fprintln(g.out, ws+" out.RawByte('[')")
fmt.Fprintln(g.out, ws+" for "+iVar+", "+vVar+" := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {")
fmt.Fprintln(g.out, ws+" out.RawByte(',')")
fmt.Fprintln(g.out, ws+" }")
if err := g.genTypeEncoder(elem, vVar, tags, indent+2, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+" }")
fmt.Fprintln(g.out, ws+" out.RawByte(']')")
fmt.Fprintln(g.out, ws+"}")
}
case reflect.Array:
elem := t.Elem()
iVar := g.uniqueVarName()
if t.Elem().Kind() == reflect.Uint8 && elem.Name() == "uint8" {
fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+"[:])")
} else {
fmt.Fprintln(g.out, ws+"out.RawByte('[')")
fmt.Fprintln(g.out, ws+"for "+iVar+" := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {")
fmt.Fprintln(g.out, ws+" out.RawByte(',')")
fmt.Fprintln(g.out, ws+" }")
if err := g.genTypeEncoder(elem, "("+in+")["+iVar+"]", tags, indent+1, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+"}")
fmt.Fprintln(g.out, ws+"out.RawByte(']')")
}
case reflect.Struct:
enc := g.getEncoderName(t)
g.addType(t)
fmt.Fprintln(g.out, ws+enc+"(out, "+in+")")
case reflect.Ptr:
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil {")
fmt.Fprintln(g.out, ws+` out.RawString("null")`)
fmt.Fprintln(g.out, ws+"} else {")
}
if err := g.genTypeEncoder(t.Elem(), "*"+in, tags, indent+1, false); err != nil {
return err
}
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"}")
}
case reflect.Map:
key := t.Key()
keyEnc, ok := primitiveStringEncoders[key.Kind()]
if !ok && !hasCustomMarshaler(key) {
return fmt.Errorf("map key type %v not supported: only string and integer keys and types implementing Marshaler interfaces are allowed", key)
} // else assume the caller knows what they are doing and that the custom marshaler performs the translation from the key type to a string or integer
tmpVar := g.uniqueVarName()
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilMapAsEmpty) == 0 {")
fmt.Fprintln(g.out, ws+" out.RawString(`null`)")
fmt.Fprintln(g.out, ws+"} else {")
} else {
fmt.Fprintln(g.out, ws+"{")
}
fmt.Fprintln(g.out, ws+" out.RawByte('{')")
fmt.Fprintln(g.out, ws+" "+tmpVar+"First := true")
fmt.Fprintln(g.out, ws+" for "+tmpVar+"Name, "+tmpVar+"Value := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+tmpVar+"First { "+tmpVar+"First = false } else { out.RawByte(',') }")
// NOTE: extra check for TextMarshaler. It overrides default methods.
if reflect.PtrTo(key).Implements(reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()) {
fmt.Fprintln(g.out, ws+" "+fmt.Sprintf("out.RawText(("+tmpVar+"Name).MarshalText()"+")"))
} else if keyEnc != "" {
fmt.Fprintln(g.out, ws+" "+fmt.Sprintf(keyEnc, tmpVar+"Name"))
} else {
if err := g.genTypeEncoder(key, tmpVar+"Name", tags, indent+2, false); err != nil {
return err
}
}
fmt.Fprintln(g.out, ws+" out.RawByte(':')")
if err := g.genTypeEncoder(t.Elem(), tmpVar+"Value", tags, indent+2, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+" }")
fmt.Fprintln(g.out, ws+" out.RawByte('}')")
fmt.Fprintln(g.out, ws+"}")
case reflect.Interface:
if t.NumMethod() != 0 {
return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t)
}
fmt.Fprintln(g.out, ws+"if m, ok := "+in+".(easyjson.Marshaler); ok {")
fmt.Fprintln(g.out, ws+" m.MarshalEasyJSON(out)")
fmt.Fprintln(g.out, ws+"} else if m, ok := "+in+".(json.Marshaler); ok {")
fmt.Fprintln(g.out, ws+" out.Raw(m.MarshalJSON())")
fmt.Fprintln(g.out, ws+"} else {")
fmt.Fprintln(g.out, ws+" out.Raw(json.Marshal("+in+"))")
fmt.Fprintln(g.out, ws+"}")
default:
return fmt.Errorf("don't know how to encode %v", t)
}
return nil
} | go | 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.Fprintf(g.out, ws+enc+"\n", in)
return nil
} else if enc := primitiveEncoders[t.Kind()]; enc != "" {
fmt.Fprintf(g.out, ws+enc+"\n", in)
return nil
}
switch t.Kind() {
case reflect.Slice:
elem := t.Elem()
iVar := g.uniqueVarName()
vVar := g.uniqueVarName()
if t.Elem().Kind() == reflect.Uint8 && elem.Name() == "uint8" {
fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+")")
} else {
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilSliceAsEmpty) == 0 {")
fmt.Fprintln(g.out, ws+` out.RawString("null")`)
fmt.Fprintln(g.out, ws+"} else {")
} else {
fmt.Fprintln(g.out, ws+"{")
}
fmt.Fprintln(g.out, ws+" out.RawByte('[')")
fmt.Fprintln(g.out, ws+" for "+iVar+", "+vVar+" := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {")
fmt.Fprintln(g.out, ws+" out.RawByte(',')")
fmt.Fprintln(g.out, ws+" }")
if err := g.genTypeEncoder(elem, vVar, tags, indent+2, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+" }")
fmt.Fprintln(g.out, ws+" out.RawByte(']')")
fmt.Fprintln(g.out, ws+"}")
}
case reflect.Array:
elem := t.Elem()
iVar := g.uniqueVarName()
if t.Elem().Kind() == reflect.Uint8 && elem.Name() == "uint8" {
fmt.Fprintln(g.out, ws+"out.Base64Bytes("+in+"[:])")
} else {
fmt.Fprintln(g.out, ws+"out.RawByte('[')")
fmt.Fprintln(g.out, ws+"for "+iVar+" := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+iVar+" > 0 {")
fmt.Fprintln(g.out, ws+" out.RawByte(',')")
fmt.Fprintln(g.out, ws+" }")
if err := g.genTypeEncoder(elem, "("+in+")["+iVar+"]", tags, indent+1, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+"}")
fmt.Fprintln(g.out, ws+"out.RawByte(']')")
}
case reflect.Struct:
enc := g.getEncoderName(t)
g.addType(t)
fmt.Fprintln(g.out, ws+enc+"(out, "+in+")")
case reflect.Ptr:
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil {")
fmt.Fprintln(g.out, ws+` out.RawString("null")`)
fmt.Fprintln(g.out, ws+"} else {")
}
if err := g.genTypeEncoder(t.Elem(), "*"+in, tags, indent+1, false); err != nil {
return err
}
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"}")
}
case reflect.Map:
key := t.Key()
keyEnc, ok := primitiveStringEncoders[key.Kind()]
if !ok && !hasCustomMarshaler(key) {
return fmt.Errorf("map key type %v not supported: only string and integer keys and types implementing Marshaler interfaces are allowed", key)
} // else assume the caller knows what they are doing and that the custom marshaler performs the translation from the key type to a string or integer
tmpVar := g.uniqueVarName()
if !assumeNonEmpty {
fmt.Fprintln(g.out, ws+"if "+in+" == nil && (out.Flags & jwriter.NilMapAsEmpty) == 0 {")
fmt.Fprintln(g.out, ws+" out.RawString(`null`)")
fmt.Fprintln(g.out, ws+"} else {")
} else {
fmt.Fprintln(g.out, ws+"{")
}
fmt.Fprintln(g.out, ws+" out.RawByte('{')")
fmt.Fprintln(g.out, ws+" "+tmpVar+"First := true")
fmt.Fprintln(g.out, ws+" for "+tmpVar+"Name, "+tmpVar+"Value := range "+in+" {")
fmt.Fprintln(g.out, ws+" if "+tmpVar+"First { "+tmpVar+"First = false } else { out.RawByte(',') }")
// NOTE: extra check for TextMarshaler. It overrides default methods.
if reflect.PtrTo(key).Implements(reflect.TypeOf((*encoding.TextMarshaler)(nil)).Elem()) {
fmt.Fprintln(g.out, ws+" "+fmt.Sprintf("out.RawText(("+tmpVar+"Name).MarshalText()"+")"))
} else if keyEnc != "" {
fmt.Fprintln(g.out, ws+" "+fmt.Sprintf(keyEnc, tmpVar+"Name"))
} else {
if err := g.genTypeEncoder(key, tmpVar+"Name", tags, indent+2, false); err != nil {
return err
}
}
fmt.Fprintln(g.out, ws+" out.RawByte(':')")
if err := g.genTypeEncoder(t.Elem(), tmpVar+"Value", tags, indent+2, false); err != nil {
return err
}
fmt.Fprintln(g.out, ws+" }")
fmt.Fprintln(g.out, ws+" out.RawByte('}')")
fmt.Fprintln(g.out, ws+"}")
case reflect.Interface:
if t.NumMethod() != 0 {
return fmt.Errorf("interface type %v not supported: only interface{} is allowed", t)
}
fmt.Fprintln(g.out, ws+"if m, ok := "+in+".(easyjson.Marshaler); ok {")
fmt.Fprintln(g.out, ws+" m.MarshalEasyJSON(out)")
fmt.Fprintln(g.out, ws+"} else if m, ok := "+in+".(json.Marshaler); ok {")
fmt.Fprintln(g.out, ws+" out.Raw(m.MarshalJSON())")
fmt.Fprintln(g.out, ws+"} else {")
fmt.Fprintln(g.out, ws+" out.Raw(json.Marshal("+in+"))")
fmt.Fprintln(g.out, ws+"}")
default:
return fmt.Errorf("don't know how to encode %v", t)
}
return nil
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"genTypeEncoderNoCheck",
"(",
"t",
"reflect",
".",
"Type",
",",
"in",
"string",
",",
"tags",
"fieldTags",
",",
"indent",
"int",
",",
"assumeNonEmpty",
"bool",
")",
"error",
"{",
"ws",
":=",
"strings",
".",
"Repeat",
"(",
"\"",
"\"",
",",
"indent",
")",
"\n\n",
"// Check whether type is primitive, needs to be done after interface check.",
"if",
"enc",
":=",
"primitiveStringEncoders",
"[",
"t",
".",
"Kind",
"(",
")",
"]",
";",
"enc",
"!=",
"\"",
"\"",
"&&",
"tags",
".",
"asString",
"{",
"fmt",
".",
"Fprintf",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"enc",
"+",
"\"",
"\\n",
"\"",
",",
"in",
")",
"\n",
"return",
"nil",
"\n",
"}",
"else",
"if",
"enc",
":=",
"primitiveEncoders",
"[",
"t",
".",
"Kind",
"(",
")",
"]",
";",
"enc",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintf",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"enc",
"+",
"\"",
"\\n",
"\"",
",",
"in",
")",
"\n",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"t",
".",
"Kind",
"(",
")",
"{",
"case",
"reflect",
".",
"Slice",
":",
"elem",
":=",
"t",
".",
"Elem",
"(",
")",
"\n",
"iVar",
":=",
"g",
".",
"uniqueVarName",
"(",
")",
"\n",
"vVar",
":=",
"g",
".",
"uniqueVarName",
"(",
")",
"\n\n",
"if",
"t",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Uint8",
"&&",
"elem",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"if",
"!",
"assumeNonEmpty",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"` out.RawString(\"null\")`",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"iVar",
"+",
"\"",
"\"",
"+",
"vVar",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"iVar",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genTypeEncoder",
"(",
"elem",
",",
"vVar",
",",
"tags",
",",
"indent",
"+",
"2",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"case",
"reflect",
".",
"Array",
":",
"elem",
":=",
"t",
".",
"Elem",
"(",
")",
"\n",
"iVar",
":=",
"g",
".",
"uniqueVarName",
"(",
")",
"\n\n",
"if",
"t",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Uint8",
"&&",
"elem",
".",
"Name",
"(",
")",
"==",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"iVar",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"iVar",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genTypeEncoder",
"(",
"elem",
",",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
"+",
"iVar",
"+",
"\"",
"\"",
",",
"tags",
",",
"indent",
"+",
"1",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"case",
"reflect",
".",
"Struct",
":",
"enc",
":=",
"g",
".",
"getEncoderName",
"(",
"t",
")",
"\n",
"g",
".",
"addType",
"(",
"t",
")",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"enc",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n\n",
"case",
"reflect",
".",
"Ptr",
":",
"if",
"!",
"assumeNonEmpty",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"` out.RawString(\"null\")`",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genTypeEncoder",
"(",
"t",
".",
"Elem",
"(",
")",
",",
"\"",
"\"",
"+",
"in",
",",
"tags",
",",
"indent",
"+",
"1",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"assumeNonEmpty",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"case",
"reflect",
".",
"Map",
":",
"key",
":=",
"t",
".",
"Key",
"(",
")",
"\n",
"keyEnc",
",",
"ok",
":=",
"primitiveStringEncoders",
"[",
"key",
".",
"Kind",
"(",
")",
"]",
"\n",
"if",
"!",
"ok",
"&&",
"!",
"hasCustomMarshaler",
"(",
"key",
")",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"key",
")",
"\n",
"}",
"// else assume the caller knows what they are doing and that the custom marshaler performs the translation from the key type to a string or integer",
"\n",
"tmpVar",
":=",
"g",
".",
"uniqueVarName",
"(",
")",
"\n\n",
"if",
"!",
"assumeNonEmpty",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
")",
"\n\n",
"// NOTE: extra check for TextMarshaler. It overrides default methods.",
"if",
"reflect",
".",
"PtrTo",
"(",
"key",
")",
".",
"Implements",
"(",
"reflect",
".",
"TypeOf",
"(",
"(",
"*",
"encoding",
".",
"TextMarshaler",
")",
"(",
"nil",
")",
")",
".",
"Elem",
"(",
")",
")",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
"+",
"tmpVar",
"+",
"\"",
"\"",
"+",
"\"",
"\"",
")",
")",
"\n",
"}",
"else",
"if",
"keyEnc",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"fmt",
".",
"Sprintf",
"(",
"keyEnc",
",",
"tmpVar",
"+",
"\"",
"\"",
")",
")",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"g",
".",
"genTypeEncoder",
"(",
"key",
",",
"tmpVar",
"+",
"\"",
"\"",
",",
"tags",
",",
"indent",
"+",
"2",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n\n",
"if",
"err",
":=",
"g",
".",
"genTypeEncoder",
"(",
"t",
".",
"Elem",
"(",
")",
",",
"tmpVar",
"+",
"\"",
"\"",
",",
"tags",
",",
"indent",
"+",
"2",
",",
"false",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n\n",
"case",
"reflect",
".",
"Interface",
":",
"if",
"t",
".",
"NumMethod",
"(",
")",
"!=",
"0",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
"+",
"in",
"+",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"g",
".",
"out",
",",
"ws",
"+",
"\"",
"\"",
")",
"\n\n",
"default",
":",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"t",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] | // genTypeEncoderNoCheck generates code that encodes in of type t into the writer. | [
"genTypeEncoderNoCheck",
"generates",
"code",
"that",
"encodes",
"in",
"of",
"type",
"t",
"into",
"the",
"writer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/gen/encoder.go#L122-L264 | train |
mailru/easyjson | bootstrap/bootstrap.go | writeMain | 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.Fprintln(f, "// the actual generator.")
fmt.Fprintln(f)
fmt.Fprintln(f, "package main")
fmt.Fprintln(f)
fmt.Fprintln(f, "import (")
fmt.Fprintln(f, ` "fmt"`)
fmt.Fprintln(f, ` "os"`)
fmt.Fprintln(f)
fmt.Fprintf(f, " %q\n", genPackage)
if len(g.Types) > 0 {
fmt.Fprintln(f)
fmt.Fprintf(f, " pkg %q\n", g.PkgPath)
}
fmt.Fprintln(f, ")")
fmt.Fprintln(f)
fmt.Fprintln(f, "func main() {")
fmt.Fprintf(f, " g := gen.NewGenerator(%q)\n", filepath.Base(g.OutName))
fmt.Fprintf(f, " g.SetPkg(%q, %q)\n", g.PkgName, g.PkgPath)
if g.BuildTags != "" {
fmt.Fprintf(f, " g.SetBuildTags(%q)\n", g.BuildTags)
}
if g.SnakeCase {
fmt.Fprintln(f, " g.UseSnakeCase()")
}
if g.LowerCamelCase {
fmt.Fprintln(f, " g.UseLowerCamelCase()")
}
if g.OmitEmpty {
fmt.Fprintln(f, " g.OmitEmpty()")
}
if g.NoStdMarshalers {
fmt.Fprintln(f, " g.NoStdMarshalers()")
}
if g.DisallowUnknownFields {
fmt.Fprintln(f, " g.DisallowUnknownFields()")
}
sort.Strings(g.Types)
for _, v := range g.Types {
fmt.Fprintln(f, " g.Add(pkg.EasyJSON_exporter_"+v+"(nil))")
}
fmt.Fprintln(f, " if err := g.Run(os.Stdout); err != nil {")
fmt.Fprintln(f, " fmt.Fprintln(os.Stderr, err)")
fmt.Fprintln(f, " os.Exit(1)")
fmt.Fprintln(f, " }")
fmt.Fprintln(f, "}")
src := f.Name()
if err := f.Close(); err != nil {
return src, err
}
dest := src + ".go"
return dest, os.Rename(src, dest)
} | go | 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.Fprintln(f, "// the actual generator.")
fmt.Fprintln(f)
fmt.Fprintln(f, "package main")
fmt.Fprintln(f)
fmt.Fprintln(f, "import (")
fmt.Fprintln(f, ` "fmt"`)
fmt.Fprintln(f, ` "os"`)
fmt.Fprintln(f)
fmt.Fprintf(f, " %q\n", genPackage)
if len(g.Types) > 0 {
fmt.Fprintln(f)
fmt.Fprintf(f, " pkg %q\n", g.PkgPath)
}
fmt.Fprintln(f, ")")
fmt.Fprintln(f)
fmt.Fprintln(f, "func main() {")
fmt.Fprintf(f, " g := gen.NewGenerator(%q)\n", filepath.Base(g.OutName))
fmt.Fprintf(f, " g.SetPkg(%q, %q)\n", g.PkgName, g.PkgPath)
if g.BuildTags != "" {
fmt.Fprintf(f, " g.SetBuildTags(%q)\n", g.BuildTags)
}
if g.SnakeCase {
fmt.Fprintln(f, " g.UseSnakeCase()")
}
if g.LowerCamelCase {
fmt.Fprintln(f, " g.UseLowerCamelCase()")
}
if g.OmitEmpty {
fmt.Fprintln(f, " g.OmitEmpty()")
}
if g.NoStdMarshalers {
fmt.Fprintln(f, " g.NoStdMarshalers()")
}
if g.DisallowUnknownFields {
fmt.Fprintln(f, " g.DisallowUnknownFields()")
}
sort.Strings(g.Types)
for _, v := range g.Types {
fmt.Fprintln(f, " g.Add(pkg.EasyJSON_exporter_"+v+"(nil))")
}
fmt.Fprintln(f, " if err := g.Run(os.Stdout); err != nil {")
fmt.Fprintln(f, " fmt.Fprintln(os.Stderr, err)")
fmt.Fprintln(f, " os.Exit(1)")
fmt.Fprintln(f, " }")
fmt.Fprintln(f, "}")
src := f.Name()
if err := f.Close(); err != nil {
return src, err
}
dest := src + ".go"
return dest, os.Rename(src, dest)
} | [
"func",
"(",
"g",
"*",
"Generator",
")",
"writeMain",
"(",
")",
"(",
"path",
"string",
",",
"err",
"error",
")",
"{",
"f",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"filepath",
".",
"Dir",
"(",
"g",
".",
"OutName",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"` \"fmt\"`",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"` \"os\"`",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
",",
"\"",
"\\n",
"\"",
",",
"genPackage",
")",
"\n",
"if",
"len",
"(",
"g",
".",
"Types",
")",
">",
"0",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
",",
"\"",
"\\n",
"\"",
",",
"g",
".",
"PkgPath",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
",",
"\"",
"\\n",
"\"",
",",
"filepath",
".",
"Base",
"(",
"g",
".",
"OutName",
")",
")",
"\n",
"fmt",
".",
"Fprintf",
"(",
"f",
",",
"\"",
"\\n",
"\"",
",",
"g",
".",
"PkgName",
",",
"g",
".",
"PkgPath",
")",
"\n",
"if",
"g",
".",
"BuildTags",
"!=",
"\"",
"\"",
"{",
"fmt",
".",
"Fprintf",
"(",
"f",
",",
"\"",
"\\n",
"\"",
",",
"g",
".",
"BuildTags",
")",
"\n",
"}",
"\n",
"if",
"g",
".",
"SnakeCase",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"g",
".",
"LowerCamelCase",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"g",
".",
"OmitEmpty",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"g",
".",
"NoStdMarshalers",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"if",
"g",
".",
"DisallowUnknownFields",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"sort",
".",
"Strings",
"(",
"g",
".",
"Types",
")",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"g",
".",
"Types",
"{",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
"+",
"v",
"+",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"f",
",",
"\"",
"\"",
")",
"\n\n",
"src",
":=",
"f",
".",
"Name",
"(",
")",
"\n",
"if",
"err",
":=",
"f",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"src",
",",
"err",
"\n",
"}",
"\n\n",
"dest",
":=",
"src",
"+",
"\"",
"\"",
"\n",
"return",
"dest",
",",
"os",
".",
"Rename",
"(",
"src",
",",
"dest",
")",
"\n",
"}"
] | // writeMain creates a .go file that launches the generator if 'go run'. | [
"writeMain",
"creates",
"a",
".",
"go",
"file",
"that",
"launches",
"the",
"generator",
"if",
"go",
"run",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/bootstrap/bootstrap.go#L82-L146 | train |
mailru/easyjson | jwriter/writer.go | DumpTo | func (w *Writer) DumpTo(out io.Writer) (written int, err error) {
return w.Buffer.DumpTo(out)
} | go | func (w *Writer) DumpTo(out io.Writer) (written int, err error) {
return w.Buffer.DumpTo(out)
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"DumpTo",
"(",
"out",
"io",
".",
"Writer",
")",
"(",
"written",
"int",
",",
"err",
"error",
")",
"{",
"return",
"w",
".",
"Buffer",
".",
"DumpTo",
"(",
"out",
")",
"\n",
"}"
] | // DumpTo outputs the data to given io.Writer, resetting the buffer. | [
"DumpTo",
"outputs",
"the",
"data",
"to",
"given",
"io",
".",
"Writer",
"resetting",
"the",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L36-L38 | train |
mailru/easyjson | jwriter/writer.go | BuildBytes | func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.BuildBytes(reuse...), nil
} | go | func (w *Writer) BuildBytes(reuse ...[]byte) ([]byte, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.BuildBytes(reuse...), nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"BuildBytes",
"(",
"reuse",
"...",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"w",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"w",
".",
"Error",
"\n",
"}",
"\n\n",
"return",
"w",
".",
"Buffer",
".",
"BuildBytes",
"(",
"reuse",
"...",
")",
",",
"nil",
"\n",
"}"
] | // BuildBytes returns writer data as a single byte slice. You can optionally provide one byte slice
// as argument that it will try to reuse. | [
"BuildBytes",
"returns",
"writer",
"data",
"as",
"a",
"single",
"byte",
"slice",
".",
"You",
"can",
"optionally",
"provide",
"one",
"byte",
"slice",
"as",
"argument",
"that",
"it",
"will",
"try",
"to",
"reuse",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L42-L48 | train |
mailru/easyjson | jwriter/writer.go | ReadCloser | func (w *Writer) ReadCloser() (io.ReadCloser, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.ReadCloser(), nil
} | go | func (w *Writer) ReadCloser() (io.ReadCloser, error) {
if w.Error != nil {
return nil, w.Error
}
return w.Buffer.ReadCloser(), nil
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"ReadCloser",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"if",
"w",
".",
"Error",
"!=",
"nil",
"{",
"return",
"nil",
",",
"w",
".",
"Error",
"\n",
"}",
"\n\n",
"return",
"w",
".",
"Buffer",
".",
"ReadCloser",
"(",
")",
",",
"nil",
"\n",
"}"
] | // ReadCloser returns an io.ReadCloser that can be used to read the data.
// ReadCloser also resets the buffer. | [
"ReadCloser",
"returns",
"an",
"io",
".",
"ReadCloser",
"that",
"can",
"be",
"used",
"to",
"read",
"the",
"data",
".",
"ReadCloser",
"also",
"resets",
"the",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L52-L58 | train |
mailru/easyjson | jwriter/writer.go | Raw | 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 | 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")
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Raw",
"(",
"data",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"switch",
"{",
"case",
"w",
".",
"Error",
"!=",
"nil",
":",
"return",
"\n",
"case",
"err",
"!=",
"nil",
":",
"w",
".",
"Error",
"=",
"err",
"\n",
"case",
"len",
"(",
"data",
")",
">",
"0",
":",
"w",
".",
"Buffer",
".",
"AppendBytes",
"(",
"data",
")",
"\n",
"default",
":",
"w",
".",
"RawString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // Raw appends raw binary data to the buffer or sets the error if it is given. Useful for
// calling with results of MarshalJSON-like functions. | [
"Raw",
"appends",
"raw",
"binary",
"data",
"to",
"the",
"buffer",
"or",
"sets",
"the",
"error",
"if",
"it",
"is",
"given",
".",
"Useful",
"for",
"calling",
"with",
"results",
"of",
"MarshalJSON",
"-",
"like",
"functions",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L72-L83 | train |
mailru/easyjson | jwriter/writer.go | RawText | 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 | 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")
}
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"RawText",
"(",
"data",
"[",
"]",
"byte",
",",
"err",
"error",
")",
"{",
"switch",
"{",
"case",
"w",
".",
"Error",
"!=",
"nil",
":",
"return",
"\n",
"case",
"err",
"!=",
"nil",
":",
"w",
".",
"Error",
"=",
"err",
"\n",
"case",
"len",
"(",
"data",
")",
">",
"0",
":",
"w",
".",
"String",
"(",
"string",
"(",
"data",
")",
")",
"\n",
"default",
":",
"w",
".",
"RawString",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] | // RawText encloses raw binary data in quotes and appends in to the buffer.
// Useful for calling with results of MarshalText-like functions. | [
"RawText",
"encloses",
"raw",
"binary",
"data",
"in",
"quotes",
"and",
"appends",
"in",
"to",
"the",
"buffer",
".",
"Useful",
"for",
"calling",
"with",
"results",
"of",
"MarshalText",
"-",
"like",
"functions",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L87-L98 | train |
mailru/easyjson | jwriter/writer.go | Base64Bytes | func (w *Writer) Base64Bytes(data []byte) {
if data == nil {
w.Buffer.AppendString("null")
return
}
w.Buffer.AppendByte('"')
w.base64(data)
w.Buffer.AppendByte('"')
} | go | func (w *Writer) Base64Bytes(data []byte) {
if data == nil {
w.Buffer.AppendString("null")
return
}
w.Buffer.AppendByte('"')
w.base64(data)
w.Buffer.AppendByte('"')
} | [
"func",
"(",
"w",
"*",
"Writer",
")",
"Base64Bytes",
"(",
"data",
"[",
"]",
"byte",
")",
"{",
"if",
"data",
"==",
"nil",
"{",
"w",
".",
"Buffer",
".",
"AppendString",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"w",
".",
"Buffer",
".",
"AppendByte",
"(",
"'\"'",
")",
"\n",
"w",
".",
"base64",
"(",
"data",
")",
"\n",
"w",
".",
"Buffer",
".",
"AppendByte",
"(",
"'\"'",
")",
"\n",
"}"
] | // Base64Bytes appends data to the buffer after base64 encoding it | [
"Base64Bytes",
"appends",
"data",
"to",
"the",
"buffer",
"after",
"base64",
"encoding",
"it"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jwriter/writer.go#L101-L109 | train |
mailru/easyjson | parser/pkgpath.go | goModPath | 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] = goModPath
goModPathCache.Unlock()
}()
cmd := exec.Command("go", "env", "GOMOD")
cmd.Dir = root
stdout, err := cmd.Output()
if err != nil {
return "", err
}
goModPath = string(bytes.TrimSpace(stdout))
return goModPath, nil
} | go | 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] = goModPath
goModPathCache.Unlock()
}()
cmd := exec.Command("go", "env", "GOMOD")
cmd.Dir = root
stdout, err := cmd.Output()
if err != nil {
return "", err
}
goModPath = string(bytes.TrimSpace(stdout))
return goModPath, nil
} | [
"func",
"goModPath",
"(",
"fname",
"string",
",",
"isDir",
"bool",
")",
"(",
"string",
",",
"error",
")",
"{",
"root",
":=",
"fname",
"\n",
"if",
"!",
"isDir",
"{",
"root",
"=",
"filepath",
".",
"Dir",
"(",
"fname",
")",
"\n",
"}",
"\n\n",
"goModPathCache",
".",
"RLock",
"(",
")",
"\n",
"goModPath",
",",
"ok",
":=",
"goModPathCache",
".",
"paths",
"[",
"root",
"]",
"\n",
"goModPathCache",
".",
"RUnlock",
"(",
")",
"\n",
"if",
"ok",
"{",
"return",
"goModPath",
",",
"nil",
"\n",
"}",
"\n\n",
"defer",
"func",
"(",
")",
"{",
"goModPathCache",
".",
"Lock",
"(",
")",
"\n",
"goModPathCache",
".",
"paths",
"[",
"root",
"]",
"=",
"goModPath",
"\n",
"goModPathCache",
".",
"Unlock",
"(",
")",
"\n",
"}",
"(",
")",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"cmd",
".",
"Dir",
"=",
"root",
"\n\n",
"stdout",
",",
"err",
":=",
"cmd",
".",
"Output",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n\n",
"goModPath",
"=",
"string",
"(",
"bytes",
".",
"TrimSpace",
"(",
"stdout",
")",
")",
"\n\n",
"return",
"goModPath",
",",
"nil",
"\n",
"}"
] | // empty if no go.mod, GO111MODULE=off or go without go modules support | [
"empty",
"if",
"no",
"go",
".",
"mod",
"GO111MODULE",
"=",
"off",
"or",
"go",
"without",
"go",
"modules",
"support"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/parser/pkgpath.go#L46-L76 | train |
mailru/easyjson | buffer/pool.go | putBuf | func putBuf(buf []byte) {
size := cap(buf)
if size < config.PooledSize {
return
}
if c := buffers[size]; c != nil {
c.Put(buf[:0])
}
} | go | func putBuf(buf []byte) {
size := cap(buf)
if size < config.PooledSize {
return
}
if c := buffers[size]; c != nil {
c.Put(buf[:0])
}
} | [
"func",
"putBuf",
"(",
"buf",
"[",
"]",
"byte",
")",
"{",
"size",
":=",
"cap",
"(",
"buf",
")",
"\n",
"if",
"size",
"<",
"config",
".",
"PooledSize",
"{",
"return",
"\n",
"}",
"\n",
"if",
"c",
":=",
"buffers",
"[",
"size",
"]",
";",
"c",
"!=",
"nil",
"{",
"c",
".",
"Put",
"(",
"buf",
"[",
":",
"0",
"]",
")",
"\n",
"}",
"\n",
"}"
] | // putBuf puts a chunk to reuse pool if it can be reused. | [
"putBuf",
"puts",
"a",
"chunk",
"to",
"reuse",
"pool",
"if",
"it",
"can",
"be",
"reused",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L43-L51 | train |
mailru/easyjson | buffer/pool.go | getBuf | 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 | 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)
} | [
"func",
"getBuf",
"(",
"size",
"int",
")",
"[",
"]",
"byte",
"{",
"if",
"size",
"<",
"config",
".",
"PooledSize",
"{",
"return",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"size",
")",
"\n",
"}",
"\n\n",
"if",
"c",
":=",
"buffers",
"[",
"size",
"]",
";",
"c",
"!=",
"nil",
"{",
"v",
":=",
"c",
".",
"Get",
"(",
")",
"\n",
"if",
"v",
"!=",
"nil",
"{",
"return",
"v",
".",
"(",
"[",
"]",
"byte",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"size",
")",
"\n",
"}"
] | // getBuf gets a chunk from reuse pool or creates a new one if reuse failed. | [
"getBuf",
"gets",
"a",
"chunk",
"from",
"reuse",
"pool",
"or",
"creates",
"a",
"new",
"one",
"if",
"reuse",
"failed",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L54-L66 | train |
mailru/easyjson | buffer/pool.go | EnsureSpace | 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 = cap(b.toPool) * 2
} else {
l = config.StartSize
}
if l > config.MaxSize {
l = config.MaxSize
}
b.Buf = getBuf(l)
b.toPool = b.Buf
} | go | 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 = cap(b.toPool) * 2
} else {
l = config.StartSize
}
if l > config.MaxSize {
l = config.MaxSize
}
b.Buf = getBuf(l)
b.toPool = b.Buf
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"EnsureSpace",
"(",
"s",
"int",
")",
"{",
"if",
"cap",
"(",
"b",
".",
"Buf",
")",
"-",
"len",
"(",
"b",
".",
"Buf",
")",
">=",
"s",
"{",
"return",
"\n",
"}",
"\n",
"l",
":=",
"len",
"(",
"b",
".",
"Buf",
")",
"\n",
"if",
"l",
">",
"0",
"{",
"if",
"cap",
"(",
"b",
".",
"toPool",
")",
"!=",
"cap",
"(",
"b",
".",
"Buf",
")",
"{",
"// Chunk was reallocated, toPool can be pooled.",
"putBuf",
"(",
"b",
".",
"toPool",
")",
"\n",
"}",
"\n",
"if",
"cap",
"(",
"b",
".",
"bufs",
")",
"==",
"0",
"{",
"b",
".",
"bufs",
"=",
"make",
"(",
"[",
"]",
"[",
"]",
"byte",
",",
"0",
",",
"8",
")",
"\n",
"}",
"\n",
"b",
".",
"bufs",
"=",
"append",
"(",
"b",
".",
"bufs",
",",
"b",
".",
"Buf",
")",
"\n",
"l",
"=",
"cap",
"(",
"b",
".",
"toPool",
")",
"*",
"2",
"\n",
"}",
"else",
"{",
"l",
"=",
"config",
".",
"StartSize",
"\n",
"}",
"\n\n",
"if",
"l",
">",
"config",
".",
"MaxSize",
"{",
"l",
"=",
"config",
".",
"MaxSize",
"\n",
"}",
"\n",
"b",
".",
"Buf",
"=",
"getBuf",
"(",
"l",
")",
"\n",
"b",
".",
"toPool",
"=",
"b",
".",
"Buf",
"\n",
"}"
] | // EnsureSpace makes sure that the current chunk contains at least s free bytes,
// possibly creating a new chunk. | [
"EnsureSpace",
"makes",
"sure",
"that",
"the",
"current",
"chunk",
"contains",
"at",
"least",
"s",
"free",
"bytes",
"possibly",
"creating",
"a",
"new",
"chunk",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L80-L104 | train |
mailru/easyjson | buffer/pool.go | AppendByte | 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 | 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)
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"AppendByte",
"(",
"data",
"byte",
")",
"{",
"if",
"cap",
"(",
"b",
".",
"Buf",
")",
"==",
"len",
"(",
"b",
".",
"Buf",
")",
"{",
"// EnsureSpace won't be inlined.",
"b",
".",
"EnsureSpace",
"(",
"1",
")",
"\n",
"}",
"\n",
"b",
".",
"Buf",
"=",
"append",
"(",
"b",
".",
"Buf",
",",
"data",
")",
"\n",
"}"
] | // AppendByte appends a single byte to buffer. | [
"AppendByte",
"appends",
"a",
"single",
"byte",
"to",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L107-L112 | train |
mailru/easyjson | buffer/pool.go | AppendBytes | 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 | 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:]
}
} | [
"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",
")",
"\n",
"}",
"\n\n",
"sz",
":=",
"cap",
"(",
"b",
".",
"Buf",
")",
"-",
"len",
"(",
"b",
".",
"Buf",
")",
"\n",
"if",
"sz",
">",
"len",
"(",
"data",
")",
"{",
"sz",
"=",
"len",
"(",
"data",
")",
"\n",
"}",
"\n\n",
"b",
".",
"Buf",
"=",
"append",
"(",
"b",
".",
"Buf",
",",
"data",
"[",
":",
"sz",
"]",
"...",
")",
"\n",
"data",
"=",
"data",
"[",
"sz",
":",
"]",
"\n",
"}",
"\n",
"}"
] | // AppendBytes appends a byte slice to buffer. | [
"AppendBytes",
"appends",
"a",
"byte",
"slice",
"to",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L115-L129 | train |
mailru/easyjson | buffer/pool.go | AppendString | 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 | 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:]
}
} | [
"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",
")",
"\n",
"}",
"\n\n",
"sz",
":=",
"cap",
"(",
"b",
".",
"Buf",
")",
"-",
"len",
"(",
"b",
".",
"Buf",
")",
"\n",
"if",
"sz",
">",
"len",
"(",
"data",
")",
"{",
"sz",
"=",
"len",
"(",
"data",
")",
"\n",
"}",
"\n\n",
"b",
".",
"Buf",
"=",
"append",
"(",
"b",
".",
"Buf",
",",
"data",
"[",
":",
"sz",
"]",
"...",
")",
"\n",
"data",
"=",
"data",
"[",
"sz",
":",
"]",
"\n",
"}",
"\n",
"}"
] | // AppendBytes appends a string to buffer. | [
"AppendBytes",
"appends",
"a",
"string",
"to",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L132-L146 | train |
mailru/easyjson | buffer/pool.go | Size | func (b *Buffer) Size() int {
size := len(b.Buf)
for _, buf := range b.bufs {
size += len(buf)
}
return size
} | go | func (b *Buffer) Size() int {
size := len(b.Buf)
for _, buf := range b.bufs {
size += len(buf)
}
return size
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"Size",
"(",
")",
"int",
"{",
"size",
":=",
"len",
"(",
"b",
".",
"Buf",
")",
"\n",
"for",
"_",
",",
"buf",
":=",
"range",
"b",
".",
"bufs",
"{",
"size",
"+=",
"len",
"(",
"buf",
")",
"\n",
"}",
"\n",
"return",
"size",
"\n",
"}"
] | // Size computes the size of a buffer by adding sizes of every chunk. | [
"Size",
"computes",
"the",
"size",
"of",
"a",
"buffer",
"by",
"adding",
"sizes",
"of",
"every",
"chunk",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L149-L155 | train |
mailru/easyjson | buffer/pool.go | DumpTo | 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 | 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
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"DumpTo",
"(",
"w",
"io",
".",
"Writer",
")",
"(",
"written",
"int",
",",
"err",
"error",
")",
"{",
"var",
"n",
"int",
"\n",
"for",
"_",
",",
"buf",
":=",
"range",
"b",
".",
"bufs",
"{",
"if",
"err",
"==",
"nil",
"{",
"n",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"buf",
")",
"\n",
"written",
"+=",
"n",
"\n",
"}",
"\n",
"putBuf",
"(",
"buf",
")",
"\n",
"}",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"n",
",",
"err",
"=",
"w",
".",
"Write",
"(",
"b",
".",
"Buf",
")",
"\n",
"written",
"+=",
"n",
"\n",
"}",
"\n",
"putBuf",
"(",
"b",
".",
"toPool",
")",
"\n\n",
"b",
".",
"bufs",
"=",
"nil",
"\n",
"b",
".",
"Buf",
"=",
"nil",
"\n",
"b",
".",
"toPool",
"=",
"nil",
"\n\n",
"return",
"\n",
"}"
] | // DumpTo outputs the contents of a buffer to a writer and resets the buffer. | [
"DumpTo",
"outputs",
"the",
"contents",
"of",
"a",
"buffer",
"to",
"a",
"writer",
"and",
"resets",
"the",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L158-L179 | train |
mailru/easyjson | buffer/pool.go | BuildBytes | 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 {
ret = make([]byte, 0, size)
}
for _, buf := range b.bufs {
ret = append(ret, buf...)
putBuf(buf)
}
ret = append(ret, b.Buf...)
putBuf(b.toPool)
b.bufs = nil
b.toPool = nil
b.Buf = nil
return ret
} | go | 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 {
ret = make([]byte, 0, size)
}
for _, buf := range b.bufs {
ret = append(ret, buf...)
putBuf(buf)
}
ret = append(ret, b.Buf...)
putBuf(b.toPool)
b.bufs = nil
b.toPool = nil
b.Buf = nil
return ret
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"BuildBytes",
"(",
"reuse",
"...",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"if",
"len",
"(",
"b",
".",
"bufs",
")",
"==",
"0",
"{",
"ret",
":=",
"b",
".",
"Buf",
"\n",
"b",
".",
"toPool",
"=",
"nil",
"\n",
"b",
".",
"Buf",
"=",
"nil",
"\n",
"return",
"ret",
"\n",
"}",
"\n\n",
"var",
"ret",
"[",
"]",
"byte",
"\n",
"size",
":=",
"b",
".",
"Size",
"(",
")",
"\n\n",
"// 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",
"]",
"\n",
"}",
"else",
"{",
"ret",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"size",
")",
"\n",
"}",
"\n",
"for",
"_",
",",
"buf",
":=",
"range",
"b",
".",
"bufs",
"{",
"ret",
"=",
"append",
"(",
"ret",
",",
"buf",
"...",
")",
"\n",
"putBuf",
"(",
"buf",
")",
"\n",
"}",
"\n\n",
"ret",
"=",
"append",
"(",
"ret",
",",
"b",
".",
"Buf",
"...",
")",
"\n",
"putBuf",
"(",
"b",
".",
"toPool",
")",
"\n\n",
"b",
".",
"bufs",
"=",
"nil",
"\n",
"b",
".",
"toPool",
"=",
"nil",
"\n",
"b",
".",
"Buf",
"=",
"nil",
"\n\n",
"return",
"ret",
"\n",
"}"
] | // BuildBytes creates a single byte slice with all the contents of the buffer. Data is
// copied if it does not fit in a single chunk. You can optionally provide one byte
// slice as argument that it will try to reuse. | [
"BuildBytes",
"creates",
"a",
"single",
"byte",
"slice",
"with",
"all",
"the",
"contents",
"of",
"the",
"buffer",
".",
"Data",
"is",
"copied",
"if",
"it",
"does",
"not",
"fit",
"in",
"a",
"single",
"chunk",
".",
"You",
"can",
"optionally",
"provide",
"one",
"byte",
"slice",
"as",
"argument",
"that",
"it",
"will",
"try",
"to",
"reuse",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L184-L214 | train |
mailru/easyjson | buffer/pool.go | ReadCloser | 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 | 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
} | [
"func",
"(",
"b",
"*",
"Buffer",
")",
"ReadCloser",
"(",
")",
"io",
".",
"ReadCloser",
"{",
"ret",
":=",
"&",
"readCloser",
"{",
"0",
",",
"append",
"(",
"b",
".",
"bufs",
",",
"b",
".",
"Buf",
")",
"}",
"\n\n",
"b",
".",
"bufs",
"=",
"nil",
"\n",
"b",
".",
"toPool",
"=",
"nil",
"\n",
"b",
".",
"Buf",
"=",
"nil",
"\n\n",
"return",
"ret",
"\n",
"}"
] | // ReadCloser creates an io.ReadCloser with all the contents of the buffer. | [
"ReadCloser",
"creates",
"an",
"io",
".",
"ReadCloser",
"with",
"all",
"the",
"contents",
"of",
"the",
"buffer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/buffer/pool.go#L262-L270 | train |
mailru/easyjson | jlexer/lexer.go | FetchToken | 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
// first character.
for _, c := range r.Data[r.pos:] {
switch c {
case ':', ',':
if r.wantSep == c {
r.pos++
r.start++
r.wantSep = 0
} else {
r.errSyntax()
}
case ' ', '\t', '\r', '\n':
r.pos++
r.start++
case '"':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenString
r.fetchString()
return
case '{', '[':
if r.wantSep != 0 {
r.errSyntax()
}
r.firstElement = true
r.token.kind = tokenDelim
r.token.delimValue = r.Data[r.pos]
r.pos++
return
case '}', ']':
if !r.firstElement && (r.wantSep != ',') {
r.errSyntax()
}
r.wantSep = 0
r.token.kind = tokenDelim
r.token.delimValue = r.Data[r.pos]
r.pos++
return
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenNumber
r.fetchNumber()
return
case 'n':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenNull
r.fetchNull()
return
case 't':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenBool
r.token.boolValue = true
r.fetchTrue()
return
case 'f':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenBool
r.token.boolValue = false
r.fetchFalse()
return
default:
r.errSyntax()
return
}
}
r.fatalError = io.EOF
return
} | go | 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
// first character.
for _, c := range r.Data[r.pos:] {
switch c {
case ':', ',':
if r.wantSep == c {
r.pos++
r.start++
r.wantSep = 0
} else {
r.errSyntax()
}
case ' ', '\t', '\r', '\n':
r.pos++
r.start++
case '"':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenString
r.fetchString()
return
case '{', '[':
if r.wantSep != 0 {
r.errSyntax()
}
r.firstElement = true
r.token.kind = tokenDelim
r.token.delimValue = r.Data[r.pos]
r.pos++
return
case '}', ']':
if !r.firstElement && (r.wantSep != ',') {
r.errSyntax()
}
r.wantSep = 0
r.token.kind = tokenDelim
r.token.delimValue = r.Data[r.pos]
r.pos++
return
case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenNumber
r.fetchNumber()
return
case 'n':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenNull
r.fetchNull()
return
case 't':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenBool
r.token.boolValue = true
r.fetchTrue()
return
case 'f':
if r.wantSep != 0 {
r.errSyntax()
}
r.token.kind = tokenBool
r.token.boolValue = false
r.fetchFalse()
return
default:
r.errSyntax()
return
}
}
r.fatalError = io.EOF
return
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"FetchToken",
"(",
")",
"{",
"r",
".",
"token",
".",
"kind",
"=",
"tokenUndef",
"\n",
"r",
".",
"start",
"=",
"r",
".",
"pos",
"\n\n",
"// 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",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"// Determine the type of a token by skipping whitespace and reading the",
"// first character.",
"for",
"_",
",",
"c",
":=",
"range",
"r",
".",
"Data",
"[",
"r",
".",
"pos",
":",
"]",
"{",
"switch",
"c",
"{",
"case",
"':'",
",",
"','",
":",
"if",
"r",
".",
"wantSep",
"==",
"c",
"{",
"r",
".",
"pos",
"++",
"\n",
"r",
".",
"start",
"++",
"\n",
"r",
".",
"wantSep",
"=",
"0",
"\n",
"}",
"else",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n\n",
"case",
"' '",
",",
"'\\t'",
",",
"'\\r'",
",",
"'\\n'",
":",
"r",
".",
"pos",
"++",
"\n",
"r",
".",
"start",
"++",
"\n\n",
"case",
"'\"'",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenString",
"\n",
"r",
".",
"fetchString",
"(",
")",
"\n",
"return",
"\n\n",
"case",
"'{'",
",",
"'['",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"r",
".",
"firstElement",
"=",
"true",
"\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenDelim",
"\n",
"r",
".",
"token",
".",
"delimValue",
"=",
"r",
".",
"Data",
"[",
"r",
".",
"pos",
"]",
"\n",
"r",
".",
"pos",
"++",
"\n",
"return",
"\n\n",
"case",
"'}'",
",",
"']'",
":",
"if",
"!",
"r",
".",
"firstElement",
"&&",
"(",
"r",
".",
"wantSep",
"!=",
"','",
")",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"r",
".",
"wantSep",
"=",
"0",
"\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenDelim",
"\n",
"r",
".",
"token",
".",
"delimValue",
"=",
"r",
".",
"Data",
"[",
"r",
".",
"pos",
"]",
"\n",
"r",
".",
"pos",
"++",
"\n",
"return",
"\n\n",
"case",
"'0'",
",",
"'1'",
",",
"'2'",
",",
"'3'",
",",
"'4'",
",",
"'5'",
",",
"'6'",
",",
"'7'",
",",
"'8'",
",",
"'9'",
",",
"'-'",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenNumber",
"\n",
"r",
".",
"fetchNumber",
"(",
")",
"\n",
"return",
"\n\n",
"case",
"'n'",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenNull",
"\n",
"r",
".",
"fetchNull",
"(",
")",
"\n",
"return",
"\n\n",
"case",
"'t'",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenBool",
"\n",
"r",
".",
"token",
".",
"boolValue",
"=",
"true",
"\n",
"r",
".",
"fetchTrue",
"(",
")",
"\n",
"return",
"\n\n",
"case",
"'f'",
":",
"if",
"r",
".",
"wantSep",
"!=",
"0",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n\n",
"r",
".",
"token",
".",
"kind",
"=",
"tokenBool",
"\n",
"r",
".",
"token",
".",
"boolValue",
"=",
"false",
"\n",
"r",
".",
"fetchFalse",
"(",
")",
"\n",
"return",
"\n\n",
"default",
":",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"fatalError",
"=",
"io",
".",
"EOF",
"\n",
"return",
"\n",
"}"
] | // FetchToken scans the input for the next token. | [
"FetchToken",
"scans",
"the",
"input",
"for",
"the",
"next",
"token",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L57-L157 | train |
mailru/easyjson | jlexer/lexer.go | isTokenEnd | func isTokenEnd(c byte) bool {
return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '[' || c == ']' || c == '{' || c == '}' || c == ',' || c == ':'
} | go | func isTokenEnd(c byte) bool {
return c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '[' || c == ']' || c == '{' || c == '}' || c == ',' || c == ':'
} | [
"func",
"isTokenEnd",
"(",
"c",
"byte",
")",
"bool",
"{",
"return",
"c",
"==",
"' '",
"||",
"c",
"==",
"'\\t'",
"||",
"c",
"==",
"'\\r'",
"||",
"c",
"==",
"'\\n'",
"||",
"c",
"==",
"'['",
"||",
"c",
"==",
"']'",
"||",
"c",
"==",
"'{'",
"||",
"c",
"==",
"'}'",
"||",
"c",
"==",
"','",
"||",
"c",
"==",
"':'",
"\n",
"}"
] | // isTokenEnd returns true if the char can follow a non-delimiter token | [
"isTokenEnd",
"returns",
"true",
"if",
"the",
"char",
"can",
"follow",
"a",
"non",
"-",
"delimiter",
"token"
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L160-L162 | train |
mailru/easyjson | jlexer/lexer.go | fetchNull | 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 | 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()
}
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"fetchNull",
"(",
")",
"{",
"r",
".",
"pos",
"+=",
"4",
"\n",
"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",
"\n",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // fetchNull fetches and checks remaining bytes of null keyword. | [
"fetchNull",
"fetches",
"and",
"checks",
"remaining",
"bytes",
"of",
"null",
"keyword",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L165-L176 | train |
mailru/easyjson | jlexer/lexer.go | fetchTrue | 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 | 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()
}
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"fetchTrue",
"(",
")",
"{",
"r",
".",
"pos",
"+=",
"4",
"\n",
"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",
"\n",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // fetchTrue fetches and checks remaining bytes of true keyword. | [
"fetchTrue",
"fetches",
"and",
"checks",
"remaining",
"bytes",
"of",
"true",
"keyword",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L179-L190 | train |
mailru/easyjson | jlexer/lexer.go | fetchFalse | 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 | 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()
}
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"fetchFalse",
"(",
")",
"{",
"r",
".",
"pos",
"+=",
"5",
"\n",
"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",
"\n",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // fetchFalse fetches and checks remaining bytes of false keyword. | [
"fetchFalse",
"fetches",
"and",
"checks",
"remaining",
"bytes",
"of",
"false",
"keyword",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L193-L205 | train |
mailru/easyjson | jlexer/lexer.go | fetchNumber | 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
case (c == '+' || c == '-') && afterE:
afterE = false
default:
r.pos += i
if !isTokenEnd(c) {
r.errSyntax()
} else {
r.token.byteValue = r.Data[r.start:r.pos]
}
return
}
}
r.pos = len(r.Data)
r.token.byteValue = r.Data[r.start:]
} | go | 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
case (c == '+' || c == '-') && afterE:
afterE = false
default:
r.pos += i
if !isTokenEnd(c) {
r.errSyntax()
} else {
r.token.byteValue = r.Data[r.start:r.pos]
}
return
}
}
r.pos = len(r.Data)
r.token.byteValue = r.Data[r.start:]
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"fetchNumber",
"(",
")",
"{",
"hasE",
":=",
"false",
"\n",
"afterE",
":=",
"false",
"\n",
"hasDot",
":=",
"false",
"\n\n",
"r",
".",
"pos",
"++",
"\n",
"for",
"i",
",",
"c",
":=",
"range",
"r",
".",
"Data",
"[",
"r",
".",
"pos",
":",
"]",
"{",
"switch",
"{",
"case",
"c",
">=",
"'0'",
"&&",
"c",
"<=",
"'9'",
":",
"afterE",
"=",
"false",
"\n",
"case",
"c",
"==",
"'.'",
"&&",
"!",
"hasDot",
":",
"hasDot",
"=",
"true",
"\n",
"case",
"(",
"c",
"==",
"'e'",
"||",
"c",
"==",
"'E'",
")",
"&&",
"!",
"hasE",
":",
"hasE",
"=",
"true",
"\n",
"hasDot",
"=",
"true",
"\n",
"afterE",
"=",
"true",
"\n",
"case",
"(",
"c",
"==",
"'+'",
"||",
"c",
"==",
"'-'",
")",
"&&",
"afterE",
":",
"afterE",
"=",
"false",
"\n",
"default",
":",
"r",
".",
"pos",
"+=",
"i",
"\n",
"if",
"!",
"isTokenEnd",
"(",
"c",
")",
"{",
"r",
".",
"errSyntax",
"(",
")",
"\n",
"}",
"else",
"{",
"r",
".",
"token",
".",
"byteValue",
"=",
"r",
".",
"Data",
"[",
"r",
".",
"start",
":",
"r",
".",
"pos",
"]",
"\n",
"}",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"r",
".",
"pos",
"=",
"len",
"(",
"r",
".",
"Data",
")",
"\n",
"r",
".",
"token",
".",
"byteValue",
"=",
"r",
".",
"Data",
"[",
"r",
".",
"start",
":",
"]",
"\n",
"}"
] | // fetchNumber scans a number literal token. | [
"fetchNumber",
"scans",
"a",
"number",
"literal",
"token",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L208-L239 | train |
mailru/easyjson | jlexer/lexer.go | findStringLen | 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 | 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)
} | [
"func",
"findStringLen",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"isValid",
",",
"hasEscapes",
"bool",
",",
"length",
"int",
")",
"{",
"delta",
":=",
"0",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"data",
")",
";",
"i",
"++",
"{",
"switch",
"data",
"[",
"i",
"]",
"{",
"case",
"'\\\\'",
":",
"i",
"++",
"\n",
"delta",
"++",
"\n",
"if",
"i",
"<",
"len",
"(",
"data",
")",
"&&",
"data",
"[",
"i",
"]",
"==",
"'u'",
"{",
"delta",
"++",
"\n",
"}",
"\n",
"case",
"'\"'",
":",
"return",
"true",
",",
"(",
"delta",
">",
"0",
")",
",",
"(",
"i",
"-",
"delta",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"false",
",",
"false",
",",
"len",
"(",
"data",
")",
"\n",
"}"
] | // findStringLen tries to scan into the string literal for ending quote char to determine required size.
// The size will be exact if no escapes are present and may be inexact if there are escaped chars. | [
"findStringLen",
"tries",
"to",
"scan",
"into",
"the",
"string",
"literal",
"for",
"ending",
"quote",
"char",
"to",
"determine",
"required",
"size",
".",
"The",
"size",
"will",
"be",
"exact",
"if",
"no",
"escapes",
"are",
"present",
"and",
"may",
"be",
"inexact",
"if",
"there",
"are",
"escaped",
"chars",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L243-L260 | train |
mailru/easyjson | jlexer/lexer.go | processEscape | 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')
return 2, nil
case 'f':
r.token.byteValue = append(r.token.byteValue, '\f')
return 2, nil
case 'n':
r.token.byteValue = append(r.token.byteValue, '\n')
return 2, nil
case 'r':
r.token.byteValue = append(r.token.byteValue, '\r')
return 2, nil
case 't':
r.token.byteValue = append(r.token.byteValue, '\t')
return 2, nil
case 'u':
rr := getu4(data)
if rr < 0 {
return 0, errors.New("syntax error")
}
read := 6
if utf16.IsSurrogate(rr) {
rr1 := getu4(data[read:])
if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
read += 6
rr = dec
} else {
rr = unicode.ReplacementChar
}
}
var d [4]byte
s := utf8.EncodeRune(d[:], rr)
r.token.byteValue = append(r.token.byteValue, d[:s]...)
return read, nil
}
return 0, errors.New("syntax error")
} | go | 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')
return 2, nil
case 'f':
r.token.byteValue = append(r.token.byteValue, '\f')
return 2, nil
case 'n':
r.token.byteValue = append(r.token.byteValue, '\n')
return 2, nil
case 'r':
r.token.byteValue = append(r.token.byteValue, '\r')
return 2, nil
case 't':
r.token.byteValue = append(r.token.byteValue, '\t')
return 2, nil
case 'u':
rr := getu4(data)
if rr < 0 {
return 0, errors.New("syntax error")
}
read := 6
if utf16.IsSurrogate(rr) {
rr1 := getu4(data[read:])
if dec := utf16.DecodeRune(rr, rr1); dec != unicode.ReplacementChar {
read += 6
rr = dec
} else {
rr = unicode.ReplacementChar
}
}
var d [4]byte
s := utf8.EncodeRune(d[:], rr)
r.token.byteValue = append(r.token.byteValue, d[:s]...)
return read, nil
}
return 0, errors.New("syntax error")
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"processEscape",
"(",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"len",
"(",
"data",
")",
"<",
"2",
"{",
"return",
"0",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"data",
")",
")",
"\n",
"}",
"\n\n",
"c",
":=",
"data",
"[",
"1",
"]",
"\n",
"switch",
"c",
"{",
"case",
"'\"'",
",",
"'/'",
",",
"'\\\\'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"c",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'b'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"'\\b'",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'f'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"'\\f'",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'n'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"'\\n'",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'r'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"'\\r'",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'t'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"'\\t'",
")",
"\n",
"return",
"2",
",",
"nil",
"\n",
"case",
"'u'",
":",
"rr",
":=",
"getu4",
"(",
"data",
")",
"\n",
"if",
"rr",
"<",
"0",
"{",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"read",
":=",
"6",
"\n",
"if",
"utf16",
".",
"IsSurrogate",
"(",
"rr",
")",
"{",
"rr1",
":=",
"getu4",
"(",
"data",
"[",
"read",
":",
"]",
")",
"\n",
"if",
"dec",
":=",
"utf16",
".",
"DecodeRune",
"(",
"rr",
",",
"rr1",
")",
";",
"dec",
"!=",
"unicode",
".",
"ReplacementChar",
"{",
"read",
"+=",
"6",
"\n",
"rr",
"=",
"dec",
"\n",
"}",
"else",
"{",
"rr",
"=",
"unicode",
".",
"ReplacementChar",
"\n",
"}",
"\n",
"}",
"\n",
"var",
"d",
"[",
"4",
"]",
"byte",
"\n",
"s",
":=",
"utf8",
".",
"EncodeRune",
"(",
"d",
"[",
":",
"]",
",",
"rr",
")",
"\n",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"d",
"[",
":",
"s",
"]",
"...",
")",
"\n",
"return",
"read",
",",
"nil",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // processEscape processes a single escape sequence and returns number of bytes processed. | [
"processEscape",
"processes",
"a",
"single",
"escape",
"sequence",
"and",
"returns",
"number",
"of",
"bytes",
"processed",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L290-L338 | train |
mailru/easyjson | jlexer/lexer.go | fetchString | 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 = make([]byte, 0, length)
p := 0
for i := 0; i < len(data); {
switch data[i] {
case '"':
r.pos += i + 1
r.token.byteValue = append(r.token.byteValue, data[p:i]...)
i++
return
case '\\':
r.token.byteValue = append(r.token.byteValue, data[p:i]...)
off, err := r.processEscape(data[i:])
if err != nil {
r.errParse(err.Error())
return
}
i += off
p = i
default:
i++
}
}
r.errParse("unterminated string literal")
} | go | 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 = make([]byte, 0, length)
p := 0
for i := 0; i < len(data); {
switch data[i] {
case '"':
r.pos += i + 1
r.token.byteValue = append(r.token.byteValue, data[p:i]...)
i++
return
case '\\':
r.token.byteValue = append(r.token.byteValue, data[p:i]...)
off, err := r.processEscape(data[i:])
if err != nil {
r.errParse(err.Error())
return
}
i += off
p = i
default:
i++
}
}
r.errParse("unterminated string literal")
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"fetchString",
"(",
")",
"{",
"r",
".",
"pos",
"++",
"\n",
"data",
":=",
"r",
".",
"Data",
"[",
"r",
".",
"pos",
":",
"]",
"\n\n",
"isValid",
",",
"hasEscapes",
",",
"length",
":=",
"findStringLen",
"(",
"data",
")",
"\n",
"if",
"!",
"isValid",
"{",
"r",
".",
"pos",
"+=",
"length",
"\n",
"r",
".",
"errParse",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"!",
"hasEscapes",
"{",
"r",
".",
"token",
".",
"byteValue",
"=",
"data",
"[",
":",
"length",
"]",
"\n",
"r",
".",
"pos",
"+=",
"length",
"+",
"1",
"\n",
"return",
"\n",
"}",
"\n\n",
"r",
".",
"token",
".",
"byteValue",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"length",
")",
"\n",
"p",
":=",
"0",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"data",
")",
";",
"{",
"switch",
"data",
"[",
"i",
"]",
"{",
"case",
"'\"'",
":",
"r",
".",
"pos",
"+=",
"i",
"+",
"1",
"\n",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"data",
"[",
"p",
":",
"i",
"]",
"...",
")",
"\n",
"i",
"++",
"\n",
"return",
"\n\n",
"case",
"'\\\\'",
":",
"r",
".",
"token",
".",
"byteValue",
"=",
"append",
"(",
"r",
".",
"token",
".",
"byteValue",
",",
"data",
"[",
"p",
":",
"i",
"]",
"...",
")",
"\n",
"off",
",",
"err",
":=",
"r",
".",
"processEscape",
"(",
"data",
"[",
"i",
":",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"r",
".",
"errParse",
"(",
"err",
".",
"Error",
"(",
")",
")",
"\n",
"return",
"\n",
"}",
"\n",
"i",
"+=",
"off",
"\n",
"p",
"=",
"i",
"\n\n",
"default",
":",
"i",
"++",
"\n",
"}",
"\n",
"}",
"\n",
"r",
".",
"errParse",
"(",
"\"",
"\"",
")",
"\n",
"}"
] | // fetchString scans a string literal token. | [
"fetchString",
"scans",
"a",
"string",
"literal",
"token",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L341-L382 | train |
mailru/easyjson | jlexer/lexer.go | scanToken | func (r *Lexer) scanToken() {
if r.token.kind != tokenUndef || r.fatalError != nil {
return
}
r.FetchToken()
} | go | func (r *Lexer) scanToken() {
if r.token.kind != tokenUndef || r.fatalError != nil {
return
}
r.FetchToken()
} | [
"func",
"(",
"r",
"*",
"Lexer",
")",
"scanToken",
"(",
")",
"{",
"if",
"r",
".",
"token",
".",
"kind",
"!=",
"tokenUndef",
"||",
"r",
".",
"fatalError",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n\n",
"r",
".",
"FetchToken",
"(",
")",
"\n",
"}"
] | // scanToken scans the next token if no token is currently available in the lexer. | [
"scanToken",
"scans",
"the",
"next",
"token",
"if",
"no",
"token",
"is",
"currently",
"available",
"in",
"the",
"lexer",
"."
] | 1ea4449da9834f4d333f1cc461c374aea217d249 | https://github.com/mailru/easyjson/blob/1ea4449da9834f4d333f1cc461c374aea217d249/jlexer/lexer.go#L385-L391 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.