id
int32 0
167k
| 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
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
17,400 |
cloudfoundry/lager
|
lagerctx/context.go
|
FromContext
|
func FromContext(ctx context.Context) lager.Logger {
l, ok := ctx.Value(contextKey{}).(lager.Logger)
if !ok {
return &discardLogger{}
}
return l
}
|
go
|
func FromContext(ctx context.Context) lager.Logger {
l, ok := ctx.Value(contextKey{}).(lager.Logger)
if !ok {
return &discardLogger{}
}
return l
}
|
[
"func",
"FromContext",
"(",
"ctx",
"context",
".",
"Context",
")",
"lager",
".",
"Logger",
"{",
"l",
",",
"ok",
":=",
"ctx",
".",
"Value",
"(",
"contextKey",
"{",
"}",
")",
".",
"(",
"lager",
".",
"Logger",
")",
"\n",
"if",
"!",
"ok",
"{",
"return",
"&",
"discardLogger",
"{",
"}",
"\n",
"}",
"\n\n",
"return",
"l",
"\n",
"}"
] |
// FromContext returns the logger contained in the context, or an inert logger
// that will not log anything.
|
[
"FromContext",
"returns",
"the",
"logger",
"contained",
"in",
"the",
"context",
"or",
"an",
"inert",
"logger",
"that",
"will",
"not",
"log",
"anything",
"."
] |
54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6
|
https://github.com/cloudfoundry/lager/blob/54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6/lagerctx/context.go#L18-L25
|
17,401 |
cloudfoundry/lager
|
lagerctx/context.go
|
WithSession
|
func WithSession(ctx context.Context, task string, data ...lager.Data) lager.Logger {
return FromContext(ctx).Session(task, data...)
}
|
go
|
func WithSession(ctx context.Context, task string, data ...lager.Data) lager.Logger {
return FromContext(ctx).Session(task, data...)
}
|
[
"func",
"WithSession",
"(",
"ctx",
"context",
".",
"Context",
",",
"task",
"string",
",",
"data",
"...",
"lager",
".",
"Data",
")",
"lager",
".",
"Logger",
"{",
"return",
"FromContext",
"(",
"ctx",
")",
".",
"Session",
"(",
"task",
",",
"data",
"...",
")",
"\n",
"}"
] |
// WithSession returns a new logger that has, for convenience, had a new
// session created on it.
|
[
"WithSession",
"returns",
"a",
"new",
"logger",
"that",
"has",
"for",
"convenience",
"had",
"a",
"new",
"session",
"created",
"on",
"it",
"."
] |
54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6
|
https://github.com/cloudfoundry/lager/blob/54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6/lagerctx/context.go#L29-L31
|
17,402 |
cloudfoundry/lager
|
lagerctx/context.go
|
WithData
|
func WithData(ctx context.Context, data lager.Data) lager.Logger {
return FromContext(ctx).WithData(data)
}
|
go
|
func WithData(ctx context.Context, data lager.Data) lager.Logger {
return FromContext(ctx).WithData(data)
}
|
[
"func",
"WithData",
"(",
"ctx",
"context",
".",
"Context",
",",
"data",
"lager",
".",
"Data",
")",
"lager",
".",
"Logger",
"{",
"return",
"FromContext",
"(",
"ctx",
")",
".",
"WithData",
"(",
"data",
")",
"\n",
"}"
] |
// WithData returns a new logger that has, for convenience, had new data added
// to on it.
|
[
"WithData",
"returns",
"a",
"new",
"logger",
"that",
"has",
"for",
"convenience",
"had",
"new",
"data",
"added",
"to",
"on",
"it",
"."
] |
54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6
|
https://github.com/cloudfoundry/lager/blob/54c4f2530ddeb742ce9c9ee26f5fa758d6c1b3b6/lagerctx/context.go#L35-L37
|
17,403 |
nicolasazrak/caddy-cache
|
url_lock.go
|
Adquire
|
func (allLocks *URLLock) Adquire(key string) *sync.Mutex {
bucketIndex := allLocks.getBucketIndexForKey(key)
allLocks.globalLocks[bucketIndex].Lock()
defer allLocks.globalLocks[bucketIndex].Unlock()
lock, exists := allLocks.keys[bucketIndex][key]
if !exists {
lock = new(sync.Mutex)
allLocks.keys[bucketIndex][key] = lock
}
lock.Lock()
return lock
}
|
go
|
func (allLocks *URLLock) Adquire(key string) *sync.Mutex {
bucketIndex := allLocks.getBucketIndexForKey(key)
allLocks.globalLocks[bucketIndex].Lock()
defer allLocks.globalLocks[bucketIndex].Unlock()
lock, exists := allLocks.keys[bucketIndex][key]
if !exists {
lock = new(sync.Mutex)
allLocks.keys[bucketIndex][key] = lock
}
lock.Lock()
return lock
}
|
[
"func",
"(",
"allLocks",
"*",
"URLLock",
")",
"Adquire",
"(",
"key",
"string",
")",
"*",
"sync",
".",
"Mutex",
"{",
"bucketIndex",
":=",
"allLocks",
".",
"getBucketIndexForKey",
"(",
"key",
")",
"\n",
"allLocks",
".",
"globalLocks",
"[",
"bucketIndex",
"]",
".",
"Lock",
"(",
")",
"\n",
"defer",
"allLocks",
".",
"globalLocks",
"[",
"bucketIndex",
"]",
".",
"Unlock",
"(",
")",
"\n\n",
"lock",
",",
"exists",
":=",
"allLocks",
".",
"keys",
"[",
"bucketIndex",
"]",
"[",
"key",
"]",
"\n",
"if",
"!",
"exists",
"{",
"lock",
"=",
"new",
"(",
"sync",
".",
"Mutex",
")",
"\n",
"allLocks",
".",
"keys",
"[",
"bucketIndex",
"]",
"[",
"key",
"]",
"=",
"lock",
"\n",
"}",
"\n",
"lock",
".",
"Lock",
"(",
")",
"\n",
"return",
"lock",
"\n",
"}"
] |
// Adquire a lock for given key
|
[
"Adquire",
"a",
"lock",
"for",
"given",
"key"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/url_lock.go#L32-L44
|
17,404 |
nicolasazrak/caddy-cache
|
handler.go
|
NewHandler
|
func NewHandler(Next httpserver.Handler, config *Config) *Handler {
return &Handler{
Config: config,
Cache: NewHTTPCache(config.CacheKeyTemplate),
URLLocks: NewURLLock(),
Next: Next,
}
}
|
go
|
func NewHandler(Next httpserver.Handler, config *Config) *Handler {
return &Handler{
Config: config,
Cache: NewHTTPCache(config.CacheKeyTemplate),
URLLocks: NewURLLock(),
Next: Next,
}
}
|
[
"func",
"NewHandler",
"(",
"Next",
"httpserver",
".",
"Handler",
",",
"config",
"*",
"Config",
")",
"*",
"Handler",
"{",
"return",
"&",
"Handler",
"{",
"Config",
":",
"config",
",",
"Cache",
":",
"NewHTTPCache",
"(",
"config",
".",
"CacheKeyTemplate",
")",
",",
"URLLocks",
":",
"NewURLLock",
"(",
")",
",",
"Next",
":",
"Next",
",",
"}",
"\n",
"}"
] |
// NewHandler creates a new Handler using Next middleware
|
[
"NewHandler",
"creates",
"a",
"new",
"Handler",
"using",
"Next",
"middleware"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/handler.go#L51-L58
|
17,405 |
nicolasazrak/caddy-cache
|
storage/no_storage.go
|
Flush
|
func (b *NoStorage) Flush() error {
if f, ok := b.w.(http.Flusher); ok {
f.Flush()
}
return nil
}
|
go
|
func (b *NoStorage) Flush() error {
if f, ok := b.w.(http.Flusher); ok {
f.Flush()
}
return nil
}
|
[
"func",
"(",
"b",
"*",
"NoStorage",
")",
"Flush",
"(",
")",
"error",
"{",
"if",
"f",
",",
"ok",
":=",
"b",
".",
"w",
".",
"(",
"http",
".",
"Flusher",
")",
";",
"ok",
"{",
"f",
".",
"Flush",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Flush does nothing in a buffer
|
[
"Flush",
"does",
"nothing",
"in",
"a",
"buffer"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/no_storage.go#L28-L33
|
17,406 |
nicolasazrak/caddy-cache
|
cache_entry.go
|
NewHTTPCacheEntry
|
func NewHTTPCacheEntry(key string, request *http.Request, response *Response, config *Config) *HTTPCacheEntry {
isPublic, expiration := getCacheableStatus(request, response, config)
return &HTTPCacheEntry{
key: key,
isPublic: isPublic,
expiration: expiration,
Request: request,
Response: response,
}
}
|
go
|
func NewHTTPCacheEntry(key string, request *http.Request, response *Response, config *Config) *HTTPCacheEntry {
isPublic, expiration := getCacheableStatus(request, response, config)
return &HTTPCacheEntry{
key: key,
isPublic: isPublic,
expiration: expiration,
Request: request,
Response: response,
}
}
|
[
"func",
"NewHTTPCacheEntry",
"(",
"key",
"string",
",",
"request",
"*",
"http",
".",
"Request",
",",
"response",
"*",
"Response",
",",
"config",
"*",
"Config",
")",
"*",
"HTTPCacheEntry",
"{",
"isPublic",
",",
"expiration",
":=",
"getCacheableStatus",
"(",
"request",
",",
"response",
",",
"config",
")",
"\n\n",
"return",
"&",
"HTTPCacheEntry",
"{",
"key",
":",
"key",
",",
"isPublic",
":",
"isPublic",
",",
"expiration",
":",
"expiration",
",",
"Request",
":",
"request",
",",
"Response",
":",
"response",
",",
"}",
"\n",
"}"
] |
// NewHTTPCacheEntry creates a new HTTPCacheEntry for the given request and response
// and it also calculates if the response is public
|
[
"NewHTTPCacheEntry",
"creates",
"a",
"new",
"HTTPCacheEntry",
"for",
"the",
"given",
"request",
"and",
"response",
"and",
"it",
"also",
"calculates",
"if",
"the",
"response",
"is",
"public"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/cache_entry.go#L23-L33
|
17,407 |
nicolasazrak/caddy-cache
|
cache_entry.go
|
WriteBodyTo
|
func (e *HTTPCacheEntry) WriteBodyTo(w http.ResponseWriter) error {
if !e.isPublic {
return e.writePrivateResponse(w)
}
return e.writePublicResponse(w)
}
|
go
|
func (e *HTTPCacheEntry) WriteBodyTo(w http.ResponseWriter) error {
if !e.isPublic {
return e.writePrivateResponse(w)
}
return e.writePublicResponse(w)
}
|
[
"func",
"(",
"e",
"*",
"HTTPCacheEntry",
")",
"WriteBodyTo",
"(",
"w",
"http",
".",
"ResponseWriter",
")",
"error",
"{",
"if",
"!",
"e",
".",
"isPublic",
"{",
"return",
"e",
".",
"writePrivateResponse",
"(",
"w",
")",
"\n",
"}",
"\n",
"return",
"e",
".",
"writePublicResponse",
"(",
"w",
")",
"\n",
"}"
] |
// WriteBodyTo sends the body to the http.ResponseWritter
|
[
"WriteBodyTo",
"sends",
"the",
"body",
"to",
"the",
"http",
".",
"ResponseWritter"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/cache_entry.go#L61-L66
|
17,408 |
nicolasazrak/caddy-cache
|
storage/file.go
|
NewFileStorage
|
func NewFileStorage(path string) (ResponseStorage, error) {
file, err := ioutil.TempFile(path, "caddy-cache-")
if err != nil {
return nil, err
}
return &FileStorage{
file: file,
subscription: NewSubscription(),
}, nil
}
|
go
|
func NewFileStorage(path string) (ResponseStorage, error) {
file, err := ioutil.TempFile(path, "caddy-cache-")
if err != nil {
return nil, err
}
return &FileStorage{
file: file,
subscription: NewSubscription(),
}, nil
}
|
[
"func",
"NewFileStorage",
"(",
"path",
"string",
")",
"(",
"ResponseStorage",
",",
"error",
")",
"{",
"file",
",",
"err",
":=",
"ioutil",
".",
"TempFile",
"(",
"path",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"FileStorage",
"{",
"file",
":",
"file",
",",
"subscription",
":",
"NewSubscription",
"(",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewFileStorage creates a new temp file that will be used as a the storage of the cache entry
|
[
"NewFileStorage",
"creates",
"a",
"new",
"temp",
"file",
"that",
"will",
"be",
"used",
"as",
"a",
"the",
"storage",
"of",
"the",
"cache",
"entry"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L16-L25
|
17,409 |
nicolasazrak/caddy-cache
|
storage/file.go
|
Flush
|
func (f *FileStorage) Flush() error {
defer f.subscription.NotifyAll(0)
return f.file.Sync()
}
|
go
|
func (f *FileStorage) Flush() error {
defer f.subscription.NotifyAll(0)
return f.file.Sync()
}
|
[
"func",
"(",
"f",
"*",
"FileStorage",
")",
"Flush",
"(",
")",
"error",
"{",
"defer",
"f",
".",
"subscription",
".",
"NotifyAll",
"(",
"0",
")",
"\n",
"return",
"f",
".",
"file",
".",
"Sync",
"(",
")",
"\n",
"}"
] |
// Flush syncs the underlying file
|
[
"Flush",
"syncs",
"the",
"underlying",
"file"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L33-L36
|
17,410 |
nicolasazrak/caddy-cache
|
storage/file.go
|
Clean
|
func (f *FileStorage) Clean() error {
f.subscription.WaitAll() // Wait until every subscriber ends waiting every result
return os.Remove(f.file.Name())
}
|
go
|
func (f *FileStorage) Clean() error {
f.subscription.WaitAll() // Wait until every subscriber ends waiting every result
return os.Remove(f.file.Name())
}
|
[
"func",
"(",
"f",
"*",
"FileStorage",
")",
"Clean",
"(",
")",
"error",
"{",
"f",
".",
"subscription",
".",
"WaitAll",
"(",
")",
"// Wait until every subscriber ends waiting every result",
"\n",
"return",
"os",
".",
"Remove",
"(",
"f",
".",
"file",
".",
"Name",
"(",
")",
")",
"\n",
"}"
] |
// Clean removes the file
|
[
"Clean",
"removes",
"the",
"file"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L39-L42
|
17,411 |
nicolasazrak/caddy-cache
|
storage/file.go
|
Close
|
func (f *FileStorage) Close() error {
f.subscription.Close()
return f.file.Close()
}
|
go
|
func (f *FileStorage) Close() error {
f.subscription.Close()
return f.file.Close()
}
|
[
"func",
"(",
"f",
"*",
"FileStorage",
")",
"Close",
"(",
")",
"error",
"{",
"f",
".",
"subscription",
".",
"Close",
"(",
")",
"\n",
"return",
"f",
".",
"file",
".",
"Close",
"(",
")",
"\n",
"}"
] |
// Close the underlying file
|
[
"Close",
"the",
"underlying",
"file"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L45-L48
|
17,412 |
nicolasazrak/caddy-cache
|
storage/file.go
|
GetReader
|
func (f *FileStorage) GetReader() (io.ReadCloser, error) {
newFile, err := os.Open(f.file.Name())
if err != nil {
return nil, err
}
return &FileReader{
content: newFile,
subscription: f.subscription.NewSubscriber(),
unsubscribe: f.subscription.RemoveSubscriber,
}, nil
}
|
go
|
func (f *FileStorage) GetReader() (io.ReadCloser, error) {
newFile, err := os.Open(f.file.Name())
if err != nil {
return nil, err
}
return &FileReader{
content: newFile,
subscription: f.subscription.NewSubscriber(),
unsubscribe: f.subscription.RemoveSubscriber,
}, nil
}
|
[
"func",
"(",
"f",
"*",
"FileStorage",
")",
"GetReader",
"(",
")",
"(",
"io",
".",
"ReadCloser",
",",
"error",
")",
"{",
"newFile",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"f",
".",
"file",
".",
"Name",
"(",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"FileReader",
"{",
"content",
":",
"newFile",
",",
"subscription",
":",
"f",
".",
"subscription",
".",
"NewSubscriber",
"(",
")",
",",
"unsubscribe",
":",
"f",
".",
"subscription",
".",
"RemoveSubscriber",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// GetReader returns a new file descriptor to the same file
|
[
"GetReader",
"returns",
"a",
"new",
"file",
"descriptor",
"to",
"the",
"same",
"file"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L51-L61
|
17,413 |
nicolasazrak/caddy-cache
|
storage/file.go
|
Close
|
func (r *FileReader) Close() error {
err := r.content.Close()
r.unsubscribe(r.subscription)
return err
}
|
go
|
func (r *FileReader) Close() error {
err := r.content.Close()
r.unsubscribe(r.subscription)
return err
}
|
[
"func",
"(",
"r",
"*",
"FileReader",
")",
"Close",
"(",
")",
"error",
"{",
"err",
":=",
"r",
".",
"content",
".",
"Close",
"(",
")",
"\n",
"r",
".",
"unsubscribe",
"(",
"r",
".",
"subscription",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Close closes the underlying storage
|
[
"Close",
"closes",
"the",
"underlying",
"storage"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/storage/file.go#L84-L88
|
17,414 |
nicolasazrak/caddy-cache
|
setup.go
|
Setup
|
func Setup(c *caddy.Controller) error {
config, err := cacheParse(c)
if err != nil {
return err
}
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return NewHandler(next, config)
})
c.OnStartup(func() error {
if config.Path == "" {
return nil
}
return os.MkdirAll(config.Path, 0600)
})
return nil
}
|
go
|
func Setup(c *caddy.Controller) error {
config, err := cacheParse(c)
if err != nil {
return err
}
httpserver.GetConfig(c).AddMiddleware(func(next httpserver.Handler) httpserver.Handler {
return NewHandler(next, config)
})
c.OnStartup(func() error {
if config.Path == "" {
return nil
}
return os.MkdirAll(config.Path, 0600)
})
return nil
}
|
[
"func",
"Setup",
"(",
"c",
"*",
"caddy",
".",
"Controller",
")",
"error",
"{",
"config",
",",
"err",
":=",
"cacheParse",
"(",
"c",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"httpserver",
".",
"GetConfig",
"(",
"c",
")",
".",
"AddMiddleware",
"(",
"func",
"(",
"next",
"httpserver",
".",
"Handler",
")",
"httpserver",
".",
"Handler",
"{",
"return",
"NewHandler",
"(",
"next",
",",
"config",
")",
"\n",
"}",
")",
"\n\n",
"c",
".",
"OnStartup",
"(",
"func",
"(",
")",
"error",
"{",
"if",
"config",
".",
"Path",
"==",
"\"",
"\"",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"os",
".",
"MkdirAll",
"(",
"config",
".",
"Path",
",",
"0600",
")",
"\n",
"}",
")",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Setup creates a new cache middleware
|
[
"Setup",
"creates",
"a",
"new",
"cache",
"middleware"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/setup.go#L37-L56
|
17,415 |
nicolasazrak/caddy-cache
|
response.go
|
NewResponse
|
func NewResponse() *Response {
r := &Response{
Code: 200,
HeaderMap: http.Header{},
body: nil,
closeNotify: make(chan bool, 1),
bodyLock: new(sync.RWMutex),
closedLock: new(sync.RWMutex),
headersLock: new(sync.RWMutex),
}
r.bodyLock.Lock()
r.closedLock.Lock()
r.headersLock.Lock()
return r
}
|
go
|
func NewResponse() *Response {
r := &Response{
Code: 200,
HeaderMap: http.Header{},
body: nil,
closeNotify: make(chan bool, 1),
bodyLock: new(sync.RWMutex),
closedLock: new(sync.RWMutex),
headersLock: new(sync.RWMutex),
}
r.bodyLock.Lock()
r.closedLock.Lock()
r.headersLock.Lock()
return r
}
|
[
"func",
"NewResponse",
"(",
")",
"*",
"Response",
"{",
"r",
":=",
"&",
"Response",
"{",
"Code",
":",
"200",
",",
"HeaderMap",
":",
"http",
".",
"Header",
"{",
"}",
",",
"body",
":",
"nil",
",",
"closeNotify",
":",
"make",
"(",
"chan",
"bool",
",",
"1",
")",
",",
"bodyLock",
":",
"new",
"(",
"sync",
".",
"RWMutex",
")",
",",
"closedLock",
":",
"new",
"(",
"sync",
".",
"RWMutex",
")",
",",
"headersLock",
":",
"new",
"(",
"sync",
".",
"RWMutex",
")",
",",
"}",
"\n\n",
"r",
".",
"bodyLock",
".",
"Lock",
"(",
")",
"\n",
"r",
".",
"closedLock",
".",
"Lock",
"(",
")",
"\n",
"r",
".",
"headersLock",
".",
"Lock",
"(",
")",
"\n",
"return",
"r",
"\n",
"}"
] |
// NewResponse returns an initialized Response.
|
[
"NewResponse",
"returns",
"an",
"initialized",
"Response",
"."
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/response.go#L27-L42
|
17,416 |
nicolasazrak/caddy-cache
|
response.go
|
writeHeader
|
func (rw *Response) writeHeader(b []byte, str string) {
if rw.wroteHeader {
return
}
if len(str) > 512 {
str = str[:512]
}
m := rw.Header()
_, hasType := m["Content-Type"]
hasTE := m.Get("Transfer-Encoding") != ""
if !hasType && !hasTE {
if b == nil {
b = []byte(str)
}
m.Set("Content-Type", http.DetectContentType(b))
}
rw.WriteHeader(200)
}
|
go
|
func (rw *Response) writeHeader(b []byte, str string) {
if rw.wroteHeader {
return
}
if len(str) > 512 {
str = str[:512]
}
m := rw.Header()
_, hasType := m["Content-Type"]
hasTE := m.Get("Transfer-Encoding") != ""
if !hasType && !hasTE {
if b == nil {
b = []byte(str)
}
m.Set("Content-Type", http.DetectContentType(b))
}
rw.WriteHeader(200)
}
|
[
"func",
"(",
"rw",
"*",
"Response",
")",
"writeHeader",
"(",
"b",
"[",
"]",
"byte",
",",
"str",
"string",
")",
"{",
"if",
"rw",
".",
"wroteHeader",
"{",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"str",
")",
">",
"512",
"{",
"str",
"=",
"str",
"[",
":",
"512",
"]",
"\n",
"}",
"\n\n",
"m",
":=",
"rw",
".",
"Header",
"(",
")",
"\n\n",
"_",
",",
"hasType",
":=",
"m",
"[",
"\"",
"\"",
"]",
"\n",
"hasTE",
":=",
"m",
".",
"Get",
"(",
"\"",
"\"",
")",
"!=",
"\"",
"\"",
"\n",
"if",
"!",
"hasType",
"&&",
"!",
"hasTE",
"{",
"if",
"b",
"==",
"nil",
"{",
"b",
"=",
"[",
"]",
"byte",
"(",
"str",
")",
"\n",
"}",
"\n",
"m",
".",
"Set",
"(",
"\"",
"\"",
",",
"http",
".",
"DetectContentType",
"(",
"b",
")",
")",
"\n",
"}",
"\n\n",
"rw",
".",
"WriteHeader",
"(",
"200",
")",
"\n",
"}"
] |
// writeHeader writes a header if it was not written yet and
// detects Content-Type if needed.
//
// bytes or str are the beginning of the response body.
// We pass both to avoid unnecessarily generate garbage
// in rw.WriteString which was created for performance reasons.
// Non-nil bytes win.
|
[
"writeHeader",
"writes",
"a",
"header",
"if",
"it",
"was",
"not",
"written",
"yet",
"and",
"detects",
"Content",
"-",
"Type",
"if",
"needed",
".",
"bytes",
"or",
"str",
"are",
"the",
"beginning",
"of",
"the",
"response",
"body",
".",
"We",
"pass",
"both",
"to",
"avoid",
"unnecessarily",
"generate",
"garbage",
"in",
"rw",
".",
"WriteString",
"which",
"was",
"created",
"for",
"performance",
"reasons",
".",
"Non",
"-",
"nil",
"bytes",
"win",
"."
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/response.go#L61-L81
|
17,417 |
nicolasazrak/caddy-cache
|
response.go
|
Write
|
func (rw *Response) Write(buf []byte) (int, error) {
if !rw.wroteHeader {
rw.writeHeader(buf, "")
}
if !rw.firstByteSent {
rw.firstByteSent = true
rw.WaitBody()
}
if rw.body != nil {
return rw.body.Write(buf)
}
return 0, errors.New("No storage")
}
|
go
|
func (rw *Response) Write(buf []byte) (int, error) {
if !rw.wroteHeader {
rw.writeHeader(buf, "")
}
if !rw.firstByteSent {
rw.firstByteSent = true
rw.WaitBody()
}
if rw.body != nil {
return rw.body.Write(buf)
}
return 0, errors.New("No storage")
}
|
[
"func",
"(",
"rw",
"*",
"Response",
")",
"Write",
"(",
"buf",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"if",
"!",
"rw",
".",
"wroteHeader",
"{",
"rw",
".",
"writeHeader",
"(",
"buf",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"!",
"rw",
".",
"firstByteSent",
"{",
"rw",
".",
"firstByteSent",
"=",
"true",
"\n",
"rw",
".",
"WaitBody",
"(",
")",
"\n",
"}",
"\n\n",
"if",
"rw",
".",
"body",
"!=",
"nil",
"{",
"return",
"rw",
".",
"body",
".",
"Write",
"(",
"buf",
")",
"\n",
"}",
"\n\n",
"return",
"0",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// Write is the io.Writer interface with the modification required
// To wait the body. This will wait until SetBody is called with
// The desired storage.
|
[
"Write",
"is",
"the",
"io",
".",
"Writer",
"interface",
"with",
"the",
"modification",
"required",
"To",
"wait",
"the",
"body",
".",
"This",
"will",
"wait",
"until",
"SetBody",
"is",
"called",
"with",
"The",
"desired",
"storage",
"."
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/response.go#L86-L101
|
17,418 |
nicolasazrak/caddy-cache
|
response.go
|
Clean
|
func (rw *Response) Clean() error {
if rw.body == nil {
return nil
}
return rw.body.Clean()
}
|
go
|
func (rw *Response) Clean() error {
if rw.body == nil {
return nil
}
return rw.body.Clean()
}
|
[
"func",
"(",
"rw",
"*",
"Response",
")",
"Clean",
"(",
")",
"error",
"{",
"if",
"rw",
".",
"body",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"rw",
".",
"body",
".",
"Clean",
"(",
")",
"\n",
"}"
] |
// Clean the body if it is set
|
[
"Clean",
"the",
"body",
"if",
"it",
"is",
"set"
] |
234a8f7be1fccfc4e88e87e9dbc14a4b679323c8
|
https://github.com/nicolasazrak/caddy-cache/blob/234a8f7be1fccfc4e88e87e9dbc14a4b679323c8/response.go#L162-L168
|
17,419 |
labstack/echo-contrib
|
session/session.go
|
Get
|
func Get(name string, c echo.Context) (*sessions.Session, error) {
store := c.Get(key).(sessions.Store)
return store.Get(c.Request(), name)
}
|
go
|
func Get(name string, c echo.Context) (*sessions.Session, error) {
store := c.Get(key).(sessions.Store)
return store.Get(c.Request(), name)
}
|
[
"func",
"Get",
"(",
"name",
"string",
",",
"c",
"echo",
".",
"Context",
")",
"(",
"*",
"sessions",
".",
"Session",
",",
"error",
")",
"{",
"store",
":=",
"c",
".",
"Get",
"(",
"key",
")",
".",
"(",
"sessions",
".",
"Store",
")",
"\n",
"return",
"store",
".",
"Get",
"(",
"c",
".",
"Request",
"(",
")",
",",
"name",
")",
"\n",
"}"
] |
// Get returns a named session.
|
[
"Get",
"returns",
"a",
"named",
"session",
"."
] |
7fa08ffe94428b4dce1c2ef3dd15648c88d88b89
|
https://github.com/labstack/echo-contrib/blob/7fa08ffe94428b4dce1c2ef3dd15648c88d88b89/session/session.go#L34-L37
|
17,420 |
labstack/echo-contrib
|
session/session.go
|
Middleware
|
func Middleware(store sessions.Store) echo.MiddlewareFunc {
c := DefaultConfig
c.Store = store
return MiddlewareWithConfig(c)
}
|
go
|
func Middleware(store sessions.Store) echo.MiddlewareFunc {
c := DefaultConfig
c.Store = store
return MiddlewareWithConfig(c)
}
|
[
"func",
"Middleware",
"(",
"store",
"sessions",
".",
"Store",
")",
"echo",
".",
"MiddlewareFunc",
"{",
"c",
":=",
"DefaultConfig",
"\n",
"c",
".",
"Store",
"=",
"store",
"\n",
"return",
"MiddlewareWithConfig",
"(",
"c",
")",
"\n",
"}"
] |
// Middleware returns a Session middleware.
|
[
"Middleware",
"returns",
"a",
"Session",
"middleware",
"."
] |
7fa08ffe94428b4dce1c2ef3dd15648c88d88b89
|
https://github.com/labstack/echo-contrib/blob/7fa08ffe94428b4dce1c2ef3dd15648c88d88b89/session/session.go#L40-L44
|
17,421 |
labstack/echo-contrib
|
casbin/casbin.go
|
Middleware
|
func Middleware(ce *casbin.Enforcer) echo.MiddlewareFunc {
c := DefaultConfig
c.Enforcer = ce
return MiddlewareWithConfig(c)
}
|
go
|
func Middleware(ce *casbin.Enforcer) echo.MiddlewareFunc {
c := DefaultConfig
c.Enforcer = ce
return MiddlewareWithConfig(c)
}
|
[
"func",
"Middleware",
"(",
"ce",
"*",
"casbin",
".",
"Enforcer",
")",
"echo",
".",
"MiddlewareFunc",
"{",
"c",
":=",
"DefaultConfig",
"\n",
"c",
".",
"Enforcer",
"=",
"ce",
"\n",
"return",
"MiddlewareWithConfig",
"(",
"c",
")",
"\n",
"}"
] |
// Middleware returns a CasbinAuth middleware.
//
// For valid credentials it calls the next handler.
// For missing or invalid credentials, it sends "401 - Unauthorized" response.
|
[
"Middleware",
"returns",
"a",
"CasbinAuth",
"middleware",
".",
"For",
"valid",
"credentials",
"it",
"calls",
"the",
"next",
"handler",
".",
"For",
"missing",
"or",
"invalid",
"credentials",
"it",
"sends",
"401",
"-",
"Unauthorized",
"response",
"."
] |
7fa08ffe94428b4dce1c2ef3dd15648c88d88b89
|
https://github.com/labstack/echo-contrib/blob/7fa08ffe94428b4dce1c2ef3dd15648c88d88b89/casbin/casbin.go#L76-L80
|
17,422 |
0xrawsec/golang-evtx
|
tools/evtxdump/evtxdump.go
|
update
|
func (s *stats) update(channel string, eventID int64) {
s.Lock()
if _, ok := s.ChannelStats[channel]; !ok {
s.ChannelStats[channel] = make(eventIDStat)
}
s.ChannelStats[channel][eventID]++
s.EventCount++
s.Unlock()
}
|
go
|
func (s *stats) update(channel string, eventID int64) {
s.Lock()
if _, ok := s.ChannelStats[channel]; !ok {
s.ChannelStats[channel] = make(eventIDStat)
}
s.ChannelStats[channel][eventID]++
s.EventCount++
s.Unlock()
}
|
[
"func",
"(",
"s",
"*",
"stats",
")",
"update",
"(",
"channel",
"string",
",",
"eventID",
"int64",
")",
"{",
"s",
".",
"Lock",
"(",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"s",
".",
"ChannelStats",
"[",
"channel",
"]",
";",
"!",
"ok",
"{",
"s",
".",
"ChannelStats",
"[",
"channel",
"]",
"=",
"make",
"(",
"eventIDStat",
")",
"\n",
"}",
"\n",
"s",
".",
"ChannelStats",
"[",
"channel",
"]",
"[",
"eventID",
"]",
"++",
"\n",
"s",
".",
"EventCount",
"++",
"\n",
"s",
".",
"Unlock",
"(",
")",
"\n",
"}"
] |
// update stats in a stat sturcture
|
[
"update",
"stats",
"in",
"a",
"stat",
"sturcture"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/tools/evtxdump/evtxdump.go#L92-L100
|
17,423 |
0xrawsec/golang-evtx
|
tools/evtxdump/evtxdump.go
|
print
|
func (s *stats) print() {
fmt.Printf("Channel,EventID,Count\n")
for c := range s.ChannelStats {
for eid, cnt := range s.ChannelStats[c] {
fmt.Printf("%s,%d,%d\n", c, eid, cnt)
}
}
//fmt.Printf("Total Events: %d\n", s.EventCount)
}
|
go
|
func (s *stats) print() {
fmt.Printf("Channel,EventID,Count\n")
for c := range s.ChannelStats {
for eid, cnt := range s.ChannelStats[c] {
fmt.Printf("%s,%d,%d\n", c, eid, cnt)
}
}
//fmt.Printf("Total Events: %d\n", s.EventCount)
}
|
[
"func",
"(",
"s",
"*",
"stats",
")",
"print",
"(",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
")",
"\n",
"for",
"c",
":=",
"range",
"s",
".",
"ChannelStats",
"{",
"for",
"eid",
",",
"cnt",
":=",
"range",
"s",
".",
"ChannelStats",
"[",
"c",
"]",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"c",
",",
"eid",
",",
"cnt",
")",
"\n",
"}",
"\n",
"}",
"\n",
"//fmt.Printf(\"Total Events: %d\\n\", s.EventCount)",
"}"
] |
// prints in CSV format
|
[
"prints",
"in",
"CSV",
"format"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/tools/evtxdump/evtxdump.go#L103-L111
|
17,424 |
0xrawsec/golang-evtx
|
tools/evtxdump/evtxdump.go
|
fetchChunkFromReader
|
func fetchChunkFromReader(r io.ReadSeeker, offset int64) (evtx.Chunk, error) {
var err error
c := evtx.NewChunk()
evtx.GoToSeeker(r, offset)
c.Offset = offset
c.Data = make([]byte, evtx.ChunkSize)
if _, err = r.Read(c.Data); err != nil {
return c, err
}
reader := bytes.NewReader(c.Data)
c.ParseChunkHeader(reader)
if err = c.Header.Validate(); err != nil {
return c, err
}
// Go to after Header
evtx.GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
err = c.ParseTemplateTable(reader)
if err != nil {
return c, err
}
err = c.ParseEventOffsets(reader)
if err != nil {
return c, err
}
return c, nil
}
|
go
|
func fetchChunkFromReader(r io.ReadSeeker, offset int64) (evtx.Chunk, error) {
var err error
c := evtx.NewChunk()
evtx.GoToSeeker(r, offset)
c.Offset = offset
c.Data = make([]byte, evtx.ChunkSize)
if _, err = r.Read(c.Data); err != nil {
return c, err
}
reader := bytes.NewReader(c.Data)
c.ParseChunkHeader(reader)
if err = c.Header.Validate(); err != nil {
return c, err
}
// Go to after Header
evtx.GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
err = c.ParseTemplateTable(reader)
if err != nil {
return c, err
}
err = c.ParseEventOffsets(reader)
if err != nil {
return c, err
}
return c, nil
}
|
[
"func",
"fetchChunkFromReader",
"(",
"r",
"io",
".",
"ReadSeeker",
",",
"offset",
"int64",
")",
"(",
"evtx",
".",
"Chunk",
",",
"error",
")",
"{",
"var",
"err",
"error",
"\n",
"c",
":=",
"evtx",
".",
"NewChunk",
"(",
")",
"\n",
"evtx",
".",
"GoToSeeker",
"(",
"r",
",",
"offset",
")",
"\n",
"c",
".",
"Offset",
"=",
"offset",
"\n",
"c",
".",
"Data",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"evtx",
".",
"ChunkSize",
")",
"\n",
"if",
"_",
",",
"err",
"=",
"r",
".",
"Read",
"(",
"c",
".",
"Data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"reader",
":=",
"bytes",
".",
"NewReader",
"(",
"c",
".",
"Data",
")",
"\n",
"c",
".",
"ParseChunkHeader",
"(",
"reader",
")",
"\n",
"if",
"err",
"=",
"c",
".",
"Header",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"// Go to after Header",
"evtx",
".",
"GoToSeeker",
"(",
"reader",
",",
"int64",
"(",
"c",
".",
"Header",
".",
"SizeHeader",
")",
")",
"\n",
"c",
".",
"ParseStringTable",
"(",
"reader",
")",
"\n",
"err",
"=",
"c",
".",
"ParseTemplateTable",
"(",
"reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"err",
"=",
"c",
".",
"ParseEventOffsets",
"(",
"reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// return an evtx.Chunk object from a reader
|
[
"return",
"an",
"evtx",
".",
"Chunk",
"object",
"from",
"a",
"reader"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/tools/evtxdump/evtxdump.go#L132-L158
|
17,425 |
0xrawsec/golang-evtx
|
tools/evtxdump/evtxdump.go
|
carveFile
|
func carveFile(datafile string, offset int64, limit int) {
chunkCnt := 0
f, err := os.Open(datafile)
if err != nil {
log.LogErrorAndExit(err)
}
defer f.Close()
f.Seek(offset, os.SEEK_SET)
dup, err := os.Open(datafile)
if err != nil {
log.LogErrorAndExit(err)
}
defer dup.Close()
dup.Seek(offset, os.SEEK_SET)
for offset := range findChunksOffsets(f) {
log.Infof("Parsing Chunk @ Offset: %d (0x%08[1]x)", offset)
chunk, err := fetchChunkFromReader(dup, offset)
if err != nil {
log.LogError(err)
}
for e := range chunk.Events() {
printEvent(e)
}
chunkCnt++
if limit > 0 && chunkCnt >= limit {
break
}
log.Debug("End of the loop")
}
}
|
go
|
func carveFile(datafile string, offset int64, limit int) {
chunkCnt := 0
f, err := os.Open(datafile)
if err != nil {
log.LogErrorAndExit(err)
}
defer f.Close()
f.Seek(offset, os.SEEK_SET)
dup, err := os.Open(datafile)
if err != nil {
log.LogErrorAndExit(err)
}
defer dup.Close()
dup.Seek(offset, os.SEEK_SET)
for offset := range findChunksOffsets(f) {
log.Infof("Parsing Chunk @ Offset: %d (0x%08[1]x)", offset)
chunk, err := fetchChunkFromReader(dup, offset)
if err != nil {
log.LogError(err)
}
for e := range chunk.Events() {
printEvent(e)
}
chunkCnt++
if limit > 0 && chunkCnt >= limit {
break
}
log.Debug("End of the loop")
}
}
|
[
"func",
"carveFile",
"(",
"datafile",
"string",
",",
"offset",
"int64",
",",
"limit",
"int",
")",
"{",
"chunkCnt",
":=",
"0",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"datafile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"LogErrorAndExit",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"f",
".",
"Close",
"(",
")",
"\n",
"f",
".",
"Seek",
"(",
"offset",
",",
"os",
".",
"SEEK_SET",
")",
"\n",
"dup",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"datafile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"LogErrorAndExit",
"(",
"err",
")",
"\n",
"}",
"\n",
"defer",
"dup",
".",
"Close",
"(",
")",
"\n",
"dup",
".",
"Seek",
"(",
"offset",
",",
"os",
".",
"SEEK_SET",
")",
"\n\n",
"for",
"offset",
":=",
"range",
"findChunksOffsets",
"(",
"f",
")",
"{",
"log",
".",
"Infof",
"(",
"\"",
"\"",
",",
"offset",
")",
"\n",
"chunk",
",",
"err",
":=",
"fetchChunkFromReader",
"(",
"dup",
",",
"offset",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"log",
".",
"LogError",
"(",
"err",
")",
"\n",
"}",
"\n",
"for",
"e",
":=",
"range",
"chunk",
".",
"Events",
"(",
")",
"{",
"printEvent",
"(",
"e",
")",
"\n",
"}",
"\n",
"chunkCnt",
"++",
"\n\n",
"if",
"limit",
">",
"0",
"&&",
"chunkCnt",
">=",
"limit",
"{",
"break",
"\n",
"}",
"\n",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// main routine to carve a file
|
[
"main",
"routine",
"to",
"carve",
"a",
"file"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/tools/evtxdump/evtxdump.go#L161-L192
|
17,426 |
0xrawsec/golang-evtx
|
tools/evtxdump/evtxdump.go
|
printEvent
|
func printEvent(e *evtx.GoEvtxMap) {
if e != nil {
t, err := e.GetTime(&evtx.SystemTimePath)
// If not between start and stop we do not print
if time.Time(start) != defaultTime && time.Time(stop) != defaultTime {
if t.Before(time.Time(start)) || t.After(time.Time(stop)) {
return
}
}
// If before start we do not print
if time.Time(start) != defaultTime {
if t.Before(time.Time(start)) {
return
}
}
// If after stop we do not print
if time.Time(stop) != defaultTime {
if t.After(time.Time(stop)) {
return
}
}
if timestamp {
if err == nil {
fmt.Printf("%d: %s\n", t.Unix(), string(evtx.ToJSON(e)))
} else {
log.Errorf("Event time not found: %s", string(evtx.ToJSON(e)))
}
} else {
fmt.Printf("%s\n", string(evtx.ToJSON(e)))
}
}
}
|
go
|
func printEvent(e *evtx.GoEvtxMap) {
if e != nil {
t, err := e.GetTime(&evtx.SystemTimePath)
// If not between start and stop we do not print
if time.Time(start) != defaultTime && time.Time(stop) != defaultTime {
if t.Before(time.Time(start)) || t.After(time.Time(stop)) {
return
}
}
// If before start we do not print
if time.Time(start) != defaultTime {
if t.Before(time.Time(start)) {
return
}
}
// If after stop we do not print
if time.Time(stop) != defaultTime {
if t.After(time.Time(stop)) {
return
}
}
if timestamp {
if err == nil {
fmt.Printf("%d: %s\n", t.Unix(), string(evtx.ToJSON(e)))
} else {
log.Errorf("Event time not found: %s", string(evtx.ToJSON(e)))
}
} else {
fmt.Printf("%s\n", string(evtx.ToJSON(e)))
}
}
}
|
[
"func",
"printEvent",
"(",
"e",
"*",
"evtx",
".",
"GoEvtxMap",
")",
"{",
"if",
"e",
"!=",
"nil",
"{",
"t",
",",
"err",
":=",
"e",
".",
"GetTime",
"(",
"&",
"evtx",
".",
"SystemTimePath",
")",
"\n\n",
"// If not between start and stop we do not print",
"if",
"time",
".",
"Time",
"(",
"start",
")",
"!=",
"defaultTime",
"&&",
"time",
".",
"Time",
"(",
"stop",
")",
"!=",
"defaultTime",
"{",
"if",
"t",
".",
"Before",
"(",
"time",
".",
"Time",
"(",
"start",
")",
")",
"||",
"t",
".",
"After",
"(",
"time",
".",
"Time",
"(",
"stop",
")",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If before start we do not print",
"if",
"time",
".",
"Time",
"(",
"start",
")",
"!=",
"defaultTime",
"{",
"if",
"t",
".",
"Before",
"(",
"time",
".",
"Time",
"(",
"start",
")",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"// If after stop we do not print",
"if",
"time",
".",
"Time",
"(",
"stop",
")",
"!=",
"defaultTime",
"{",
"if",
"t",
".",
"After",
"(",
"time",
".",
"Time",
"(",
"stop",
")",
")",
"{",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"timestamp",
"{",
"if",
"err",
"==",
"nil",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"t",
".",
"Unix",
"(",
")",
",",
"string",
"(",
"evtx",
".",
"ToJSON",
"(",
"e",
")",
")",
")",
"\n",
"}",
"else",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"string",
"(",
"evtx",
".",
"ToJSON",
"(",
"e",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"else",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"string",
"(",
"evtx",
".",
"ToJSON",
"(",
"e",
")",
")",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"}"
] |
// small routine that prints the EVTX event
|
[
"small",
"routine",
"that",
"prints",
"the",
"EVTX",
"event"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/tools/evtxdump/evtxdump.go#L195-L231
|
17,427 |
0xrawsec/golang-evtx
|
evtx/evtx.go
|
New
|
func New(filepath string) (ef File, err error) {
file, err := os.Open(filepath)
if err != nil {
return
}
ef.file = file
ef.ParseFileHeader()
return
}
|
go
|
func New(filepath string) (ef File, err error) {
file, err := os.Open(filepath)
if err != nil {
return
}
ef.file = file
ef.ParseFileHeader()
return
}
|
[
"func",
"New",
"(",
"filepath",
"string",
")",
"(",
"ef",
"File",
",",
"err",
"error",
")",
"{",
"file",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"filepath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"ef",
".",
"file",
"=",
"file",
"\n",
"ef",
".",
"ParseFileHeader",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// New EvtxFile structure initialized from file
// @filepath : filepath of the evtx file to parse
// return File : File structure initialized
|
[
"New",
"EvtxFile",
"structure",
"initialized",
"from",
"file"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/evtx.go#L72-L80
|
17,428 |
0xrawsec/golang-evtx
|
evtx/evtx.go
|
ParseFileHeader
|
func (ef *File) ParseFileHeader() {
ef.Lock()
defer ef.Unlock()
GoToSeeker(ef.file, 0)
err := encoding.Unmarshal(ef.file, &ef.Header, Endianness)
if err != nil {
panic(err)
}
}
|
go
|
func (ef *File) ParseFileHeader() {
ef.Lock()
defer ef.Unlock()
GoToSeeker(ef.file, 0)
err := encoding.Unmarshal(ef.file, &ef.Header, Endianness)
if err != nil {
panic(err)
}
}
|
[
"func",
"(",
"ef",
"*",
"File",
")",
"ParseFileHeader",
"(",
")",
"{",
"ef",
".",
"Lock",
"(",
")",
"\n",
"defer",
"ef",
".",
"Unlock",
"(",
")",
"\n",
"GoToSeeker",
"(",
"ef",
".",
"file",
",",
"0",
")",
"\n",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"ef",
".",
"file",
",",
"&",
"ef",
".",
"Header",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// ParseFileHeader parses a the file header of the file structure and modifies
// the Header of the current structure
|
[
"ParseFileHeader",
"parses",
"a",
"the",
"file",
"header",
"of",
"the",
"file",
"structure",
"and",
"modifies",
"the",
"Header",
"of",
"the",
"current",
"structure"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/evtx.go#L95-L103
|
17,429 |
0xrawsec/golang-evtx
|
evtx/evtx.go
|
FetchChunk
|
func (ef *File) FetchChunk(offset int64) (Chunk, error) {
ef.Lock()
defer ef.Unlock()
c := NewChunk()
GoToSeeker(ef.file, offset)
c.Offset = offset
c.Data = make([]byte, ChunkSize)
if _, err := ef.file.Read(c.Data); err != nil {
return c, err
}
reader := bytes.NewReader(c.Data)
c.ParseChunkHeader(reader)
// Go to after Header
GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
if err := c.ParseTemplateTable(reader); err != nil {
return c, err
}
if err := c.ParseEventOffsets(reader); err != nil {
return c, err
}
return c, nil
}
|
go
|
func (ef *File) FetchChunk(offset int64) (Chunk, error) {
ef.Lock()
defer ef.Unlock()
c := NewChunk()
GoToSeeker(ef.file, offset)
c.Offset = offset
c.Data = make([]byte, ChunkSize)
if _, err := ef.file.Read(c.Data); err != nil {
return c, err
}
reader := bytes.NewReader(c.Data)
c.ParseChunkHeader(reader)
// Go to after Header
GoToSeeker(reader, int64(c.Header.SizeHeader))
c.ParseStringTable(reader)
if err := c.ParseTemplateTable(reader); err != nil {
return c, err
}
if err := c.ParseEventOffsets(reader); err != nil {
return c, err
}
return c, nil
}
|
[
"func",
"(",
"ef",
"*",
"File",
")",
"FetchChunk",
"(",
"offset",
"int64",
")",
"(",
"Chunk",
",",
"error",
")",
"{",
"ef",
".",
"Lock",
"(",
")",
"\n",
"defer",
"ef",
".",
"Unlock",
"(",
")",
"\n",
"c",
":=",
"NewChunk",
"(",
")",
"\n",
"GoToSeeker",
"(",
"ef",
".",
"file",
",",
"offset",
")",
"\n",
"c",
".",
"Offset",
"=",
"offset",
"\n",
"c",
".",
"Data",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"ChunkSize",
")",
"\n",
"if",
"_",
",",
"err",
":=",
"ef",
".",
"file",
".",
"Read",
"(",
"c",
".",
"Data",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"reader",
":=",
"bytes",
".",
"NewReader",
"(",
"c",
".",
"Data",
")",
"\n",
"c",
".",
"ParseChunkHeader",
"(",
"reader",
")",
"\n",
"// Go to after Header",
"GoToSeeker",
"(",
"reader",
",",
"int64",
"(",
"c",
".",
"Header",
".",
"SizeHeader",
")",
")",
"\n",
"c",
".",
"ParseStringTable",
"(",
"reader",
")",
"\n",
"if",
"err",
":=",
"c",
".",
"ParseTemplateTable",
"(",
"reader",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"if",
"err",
":=",
"c",
".",
"ParseEventOffsets",
"(",
"reader",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"c",
",",
"err",
"\n",
"}",
"\n",
"return",
"c",
",",
"nil",
"\n",
"}"
] |
// FetchChunk fetches a Chunk
// @offset : offset in the current file where to find the Chunk
// return Chunk : Chunk parsed
|
[
"FetchChunk",
"fetches",
"a",
"Chunk"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/evtx.go#L153-L175
|
17,430 |
0xrawsec/golang-evtx
|
evtx/evtx.go
|
monitorChunks
|
func (ef *File) monitorChunks(stop chan bool, sleep time.Duration) (cc chan Chunk) {
cc = make(chan Chunk, 4)
sleepTime := sleep
markedChunks := datastructs.NewSyncedSet()
// Main routine to feed the Chunk Channel
go func() {
defer close(cc)
firstLoopFlag := !ef.monitorExisting
for {
// Parse the file header again to get the updates in the file
ef.ParseFileHeader()
// check if we should stop or not
select {
case <-stop:
return
default:
// go through
}
curChunks := datastructs.NewSyncedSet()
//cs := make(ChunkSorter, 0, ef.Header.ChunkCount)
ss := datastructs.NewSortedSlice(0, int(ef.Header.ChunkCount))
for i := uint16(0); i < ef.Header.ChunkCount; i++ {
offsetChunk := int64(ef.Header.ChunkDataOffset) + int64(ChunkSize)*int64(i)
chunk, err := ef.FetchRawChunk(offsetChunk)
curChunks.Add(chunk.Header.FirstEventRecID, chunk.Header.LastEventRecID)
// We append only the Chunks whose EventRecordIds have not been treated yet
if markedChunks.Contains(chunk.Header.FirstEventRecID) && markedChunks.Contains(chunk.Header.LastEventRecID) {
continue
}
switch {
case err != nil && err != io.EOF:
panic(err)
case err == nil:
markedChunks.Add(chunk.Header.FirstEventRecID)
markedChunks.Add(chunk.Header.LastEventRecID)
if !firstLoopFlag {
//cs = append(cs, chunk)
ss.Insert(chunk)
}
}
}
// Cleanup the useless cache entries (consider putting in go routine if worth)
markedChunks = datastructs.NewSyncedSet(markedChunks.Intersect(&curChunks))
// We flag out of first loop
firstLoopFlag = false
// We sort out the chunks
//sort.Stable(cs)
//for _, rc := range cs {
for rc := range ss.ReversedIter() {
chunk, err := ef.FetchChunk(rc.(Chunk).Offset)
switch {
case err != nil && err != io.EOF:
panic(err)
case err == nil:
cc <- chunk
}
}
// Check if we should quit
if ef.Header.ChunkCount >= math.MaxUint16 {
log.Info("Monitoring stopped: maximum chunk number reached")
break
}
// Sleep between loops
time.Sleep(sleepTime)
}
}()
return
}
|
go
|
func (ef *File) monitorChunks(stop chan bool, sleep time.Duration) (cc chan Chunk) {
cc = make(chan Chunk, 4)
sleepTime := sleep
markedChunks := datastructs.NewSyncedSet()
// Main routine to feed the Chunk Channel
go func() {
defer close(cc)
firstLoopFlag := !ef.monitorExisting
for {
// Parse the file header again to get the updates in the file
ef.ParseFileHeader()
// check if we should stop or not
select {
case <-stop:
return
default:
// go through
}
curChunks := datastructs.NewSyncedSet()
//cs := make(ChunkSorter, 0, ef.Header.ChunkCount)
ss := datastructs.NewSortedSlice(0, int(ef.Header.ChunkCount))
for i := uint16(0); i < ef.Header.ChunkCount; i++ {
offsetChunk := int64(ef.Header.ChunkDataOffset) + int64(ChunkSize)*int64(i)
chunk, err := ef.FetchRawChunk(offsetChunk)
curChunks.Add(chunk.Header.FirstEventRecID, chunk.Header.LastEventRecID)
// We append only the Chunks whose EventRecordIds have not been treated yet
if markedChunks.Contains(chunk.Header.FirstEventRecID) && markedChunks.Contains(chunk.Header.LastEventRecID) {
continue
}
switch {
case err != nil && err != io.EOF:
panic(err)
case err == nil:
markedChunks.Add(chunk.Header.FirstEventRecID)
markedChunks.Add(chunk.Header.LastEventRecID)
if !firstLoopFlag {
//cs = append(cs, chunk)
ss.Insert(chunk)
}
}
}
// Cleanup the useless cache entries (consider putting in go routine if worth)
markedChunks = datastructs.NewSyncedSet(markedChunks.Intersect(&curChunks))
// We flag out of first loop
firstLoopFlag = false
// We sort out the chunks
//sort.Stable(cs)
//for _, rc := range cs {
for rc := range ss.ReversedIter() {
chunk, err := ef.FetchChunk(rc.(Chunk).Offset)
switch {
case err != nil && err != io.EOF:
panic(err)
case err == nil:
cc <- chunk
}
}
// Check if we should quit
if ef.Header.ChunkCount >= math.MaxUint16 {
log.Info("Monitoring stopped: maximum chunk number reached")
break
}
// Sleep between loops
time.Sleep(sleepTime)
}
}()
return
}
|
[
"func",
"(",
"ef",
"*",
"File",
")",
"monitorChunks",
"(",
"stop",
"chan",
"bool",
",",
"sleep",
"time",
".",
"Duration",
")",
"(",
"cc",
"chan",
"Chunk",
")",
"{",
"cc",
"=",
"make",
"(",
"chan",
"Chunk",
",",
"4",
")",
"\n",
"sleepTime",
":=",
"sleep",
"\n",
"markedChunks",
":=",
"datastructs",
".",
"NewSyncedSet",
"(",
")",
"\n\n",
"// Main routine to feed the Chunk Channel",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"cc",
")",
"\n",
"firstLoopFlag",
":=",
"!",
"ef",
".",
"monitorExisting",
"\n",
"for",
"{",
"// Parse the file header again to get the updates in the file",
"ef",
".",
"ParseFileHeader",
"(",
")",
"\n\n",
"// check if we should stop or not",
"select",
"{",
"case",
"<-",
"stop",
":",
"return",
"\n",
"default",
":",
"// go through",
"}",
"\n",
"curChunks",
":=",
"datastructs",
".",
"NewSyncedSet",
"(",
")",
"\n",
"//cs := make(ChunkSorter, 0, ef.Header.ChunkCount)",
"ss",
":=",
"datastructs",
".",
"NewSortedSlice",
"(",
"0",
",",
"int",
"(",
"ef",
".",
"Header",
".",
"ChunkCount",
")",
")",
"\n",
"for",
"i",
":=",
"uint16",
"(",
"0",
")",
";",
"i",
"<",
"ef",
".",
"Header",
".",
"ChunkCount",
";",
"i",
"++",
"{",
"offsetChunk",
":=",
"int64",
"(",
"ef",
".",
"Header",
".",
"ChunkDataOffset",
")",
"+",
"int64",
"(",
"ChunkSize",
")",
"*",
"int64",
"(",
"i",
")",
"\n",
"chunk",
",",
"err",
":=",
"ef",
".",
"FetchRawChunk",
"(",
"offsetChunk",
")",
"\n",
"curChunks",
".",
"Add",
"(",
"chunk",
".",
"Header",
".",
"FirstEventRecID",
",",
"chunk",
".",
"Header",
".",
"LastEventRecID",
")",
"\n",
"// We append only the Chunks whose EventRecordIds have not been treated yet",
"if",
"markedChunks",
".",
"Contains",
"(",
"chunk",
".",
"Header",
".",
"FirstEventRecID",
")",
"&&",
"markedChunks",
".",
"Contains",
"(",
"chunk",
".",
"Header",
".",
"LastEventRecID",
")",
"{",
"continue",
"\n",
"}",
"\n",
"switch",
"{",
"case",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
":",
"panic",
"(",
"err",
")",
"\n",
"case",
"err",
"==",
"nil",
":",
"markedChunks",
".",
"Add",
"(",
"chunk",
".",
"Header",
".",
"FirstEventRecID",
")",
"\n",
"markedChunks",
".",
"Add",
"(",
"chunk",
".",
"Header",
".",
"LastEventRecID",
")",
"\n",
"if",
"!",
"firstLoopFlag",
"{",
"//cs = append(cs, chunk)",
"ss",
".",
"Insert",
"(",
"chunk",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Cleanup the useless cache entries (consider putting in go routine if worth)",
"markedChunks",
"=",
"datastructs",
".",
"NewSyncedSet",
"(",
"markedChunks",
".",
"Intersect",
"(",
"&",
"curChunks",
")",
")",
"\n\n",
"// We flag out of first loop",
"firstLoopFlag",
"=",
"false",
"\n",
"// We sort out the chunks",
"//sort.Stable(cs)",
"//for _, rc := range cs {",
"for",
"rc",
":=",
"range",
"ss",
".",
"ReversedIter",
"(",
")",
"{",
"chunk",
",",
"err",
":=",
"ef",
".",
"FetchChunk",
"(",
"rc",
".",
"(",
"Chunk",
")",
".",
"Offset",
")",
"\n",
"switch",
"{",
"case",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
":",
"panic",
"(",
"err",
")",
"\n",
"case",
"err",
"==",
"nil",
":",
"cc",
"<-",
"chunk",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Check if we should quit",
"if",
"ef",
".",
"Header",
".",
"ChunkCount",
">=",
"math",
".",
"MaxUint16",
"{",
"log",
".",
"Info",
"(",
"\"",
")",
"",
"\n",
"break",
"\n",
"}",
"\n\n",
"// Sleep between loops",
"time",
".",
"Sleep",
"(",
"sleepTime",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// monitorChunks returns a chan of the new Chunks found in the file under
// monitoring created after the monitoring started
// @stop: a channel used to stop the monitoring if needed
// @sleep: sleep time
// return (chan Chunk)
|
[
"monitorChunks",
"returns",
"a",
"chan",
"of",
"the",
"new",
"Chunks",
"found",
"in",
"the",
"file",
"under",
"monitoring",
"created",
"after",
"the",
"monitoring",
"started"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/evtx.go#L230-L303
|
17,431 |
0xrawsec/golang-evtx
|
evtx/evtx.go
|
MonitorEvents
|
func (ef *File) MonitorEvents(stop chan bool, sleep ...time.Duration) (cgem chan *GoEvtxMap) {
// Normally, it should not be needed to add a second check here on the
// EventRecordID since the record ids in the chunks are not supposed to overlap
// TODO: Add a EventRecordID marker if needed
sleepTime := DefaultMonitorSleep
if len(sleep) > 0 {
sleepTime = sleep[0]
}
jobs := MaxJobs
cgem = make(chan *GoEvtxMap, 42)
go func() {
defer close(cgem)
chanQueue := make(chan (chan *GoEvtxMap), jobs)
go func() {
defer close(chanQueue)
// this chan ends only when value is put into stop
for pc := range ef.monitorChunks(stop, sleepTime) {
// We have to create a copy here because otherwise cpc.EventsChan() fails
// I guess that because EventsChan takes a pointer to an object
// and thus the chan is taken on the pointer and since the object pointed
// changes -> kaboom
cpc := pc
ev := cpc.Events()
chanQueue <- ev
}
}()
for ec := range chanQueue {
for event := range ec {
cgem <- event
}
}
}()
return
}
|
go
|
func (ef *File) MonitorEvents(stop chan bool, sleep ...time.Duration) (cgem chan *GoEvtxMap) {
// Normally, it should not be needed to add a second check here on the
// EventRecordID since the record ids in the chunks are not supposed to overlap
// TODO: Add a EventRecordID marker if needed
sleepTime := DefaultMonitorSleep
if len(sleep) > 0 {
sleepTime = sleep[0]
}
jobs := MaxJobs
cgem = make(chan *GoEvtxMap, 42)
go func() {
defer close(cgem)
chanQueue := make(chan (chan *GoEvtxMap), jobs)
go func() {
defer close(chanQueue)
// this chan ends only when value is put into stop
for pc := range ef.monitorChunks(stop, sleepTime) {
// We have to create a copy here because otherwise cpc.EventsChan() fails
// I guess that because EventsChan takes a pointer to an object
// and thus the chan is taken on the pointer and since the object pointed
// changes -> kaboom
cpc := pc
ev := cpc.Events()
chanQueue <- ev
}
}()
for ec := range chanQueue {
for event := range ec {
cgem <- event
}
}
}()
return
}
|
[
"func",
"(",
"ef",
"*",
"File",
")",
"MonitorEvents",
"(",
"stop",
"chan",
"bool",
",",
"sleep",
"...",
"time",
".",
"Duration",
")",
"(",
"cgem",
"chan",
"*",
"GoEvtxMap",
")",
"{",
"// Normally, it should not be needed to add a second check here on the",
"// EventRecordID since the record ids in the chunks are not supposed to overlap",
"// TODO: Add a EventRecordID marker if needed",
"sleepTime",
":=",
"DefaultMonitorSleep",
"\n",
"if",
"len",
"(",
"sleep",
")",
">",
"0",
"{",
"sleepTime",
"=",
"sleep",
"[",
"0",
"]",
"\n",
"}",
"\n",
"jobs",
":=",
"MaxJobs",
"\n",
"cgem",
"=",
"make",
"(",
"chan",
"*",
"GoEvtxMap",
",",
"42",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"cgem",
")",
"\n",
"chanQueue",
":=",
"make",
"(",
"chan",
"(",
"chan",
"*",
"GoEvtxMap",
")",
",",
"jobs",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"defer",
"close",
"(",
"chanQueue",
")",
"\n",
"// this chan ends only when value is put into stop",
"for",
"pc",
":=",
"range",
"ef",
".",
"monitorChunks",
"(",
"stop",
",",
"sleepTime",
")",
"{",
"// We have to create a copy here because otherwise cpc.EventsChan() fails",
"// I guess that because EventsChan takes a pointer to an object",
"// and thus the chan is taken on the pointer and since the object pointed",
"// changes -> kaboom",
"cpc",
":=",
"pc",
"\n",
"ev",
":=",
"cpc",
".",
"Events",
"(",
")",
"\n",
"chanQueue",
"<-",
"ev",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"for",
"ec",
":=",
"range",
"chanQueue",
"{",
"for",
"event",
":=",
"range",
"ec",
"{",
"cgem",
"<-",
"event",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"\n",
"}"
] |
// MonitorEvents returns a chan pointers to all the GoEvtxMap found in the File
// under monitoring. This is the fast version
// @stop: a channel used to stop the monitoring if needed
// return (chan *GoEvtxMap)
|
[
"MonitorEvents",
"returns",
"a",
"chan",
"pointers",
"to",
"all",
"the",
"GoEvtxMap",
"found",
"in",
"the",
"File",
"under",
"monitoring",
".",
"This",
"is",
"the",
"fast",
"version"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/evtx.go#L395-L428
|
17,432 |
0xrawsec/golang-evtx
|
evtx/utils.go
|
MarshalJSON
|
func (u UTCTime) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf("\"%s\"", time.Time(u).UTC().Format(time.RFC3339Nano))), nil
}
|
go
|
func (u UTCTime) MarshalJSON() ([]byte, error) {
return []byte(fmt.Sprintf("\"%s\"", time.Time(u).UTC().Format(time.RFC3339Nano))), nil
}
|
[
"func",
"(",
"u",
"UTCTime",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"[",
"]",
"byte",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"time",
".",
"Time",
"(",
"u",
")",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"time",
".",
"RFC3339Nano",
")",
")",
")",
",",
"nil",
"\n",
"}"
] |
// MarshalJSON implements JSON serialization
|
[
"MarshalJSON",
"implements",
"JSON",
"serialization"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/utils.go#L131-L133
|
17,433 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
Validate
|
func (ch *ChunkHeader) Validate() error {
if string(ch.Magic[:]) != ChunkMagic {
return fmt.Errorf("Invalid chunk magic: %q", ch.Magic)
}
if ch.SizeHeader != 128 {
return fmt.Errorf("Invalid chunk header size: %d instead of 128", ch.SizeHeader)
}
if ch.OffsetLastRec >= ChunkSize {
return fmt.Errorf("Last event offset exceed size of chunk")
}
return nil
}
|
go
|
func (ch *ChunkHeader) Validate() error {
if string(ch.Magic[:]) != ChunkMagic {
return fmt.Errorf("Invalid chunk magic: %q", ch.Magic)
}
if ch.SizeHeader != 128 {
return fmt.Errorf("Invalid chunk header size: %d instead of 128", ch.SizeHeader)
}
if ch.OffsetLastRec >= ChunkSize {
return fmt.Errorf("Last event offset exceed size of chunk")
}
return nil
}
|
[
"func",
"(",
"ch",
"*",
"ChunkHeader",
")",
"Validate",
"(",
")",
"error",
"{",
"if",
"string",
"(",
"ch",
".",
"Magic",
"[",
":",
"]",
")",
"!=",
"ChunkMagic",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ch",
".",
"Magic",
")",
"\n",
"}",
"\n",
"if",
"ch",
".",
"SizeHeader",
"!=",
"128",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"ch",
".",
"SizeHeader",
")",
"\n",
"}",
"\n",
"if",
"ch",
".",
"OffsetLastRec",
">=",
"ChunkSize",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Validate controls the validity of the chunk header
|
[
"Validate",
"controls",
"the",
"validity",
"of",
"the",
"chunk",
"header"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L57-L68
|
17,434 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
ParseChunkHeader
|
func (c *Chunk) ParseChunkHeader(reader io.ReadSeeker) {
err := encoding.Unmarshal(reader, &c.Header, Endianness)
if err != nil {
panic(err)
}
}
|
go
|
func (c *Chunk) ParseChunkHeader(reader io.ReadSeeker) {
err := encoding.Unmarshal(reader, &c.Header, Endianness)
if err != nil {
panic(err)
}
}
|
[
"func",
"(",
"c",
"*",
"Chunk",
")",
"ParseChunkHeader",
"(",
"reader",
"io",
".",
"ReadSeeker",
")",
"{",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"c",
".",
"Header",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}"
] |
// ParseChunkHeader parses a chunk header at offset
|
[
"ParseChunkHeader",
"parses",
"a",
"chunk",
"header",
"at",
"offset"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L111-L116
|
17,435 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
Less
|
func (c Chunk) Less(s *datastructs.Sortable) bool {
other := (*s).(Chunk)
return c.Header.NumFirstRecLog < other.Header.NumFirstRecLog
}
|
go
|
func (c Chunk) Less(s *datastructs.Sortable) bool {
other := (*s).(Chunk)
return c.Header.NumFirstRecLog < other.Header.NumFirstRecLog
}
|
[
"func",
"(",
"c",
"Chunk",
")",
"Less",
"(",
"s",
"*",
"datastructs",
".",
"Sortable",
")",
"bool",
"{",
"other",
":=",
"(",
"*",
"s",
")",
".",
"(",
"Chunk",
")",
"\n",
"return",
"c",
".",
"Header",
".",
"NumFirstRecLog",
"<",
"other",
".",
"Header",
".",
"NumFirstRecLog",
"\n",
"}"
] |
// Less implement datastructs.Sortable
|
[
"Less",
"implement",
"datastructs",
".",
"Sortable"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L119-L122
|
17,436 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
ParseStringTable
|
func (c *Chunk) ParseStringTable(reader io.ReadSeeker) {
strOffset := int32(0)
for i := int64(0); i < sizeStringBucket*4; i += 4 {
encoding.Unmarshal(reader, &strOffset, Endianness)
if strOffset > 0 {
cs, err := StringAt(reader, int64(strOffset))
if err != nil {
if !ModeCarving {
panic(err)
}
}
c.StringTable[strOffset] = cs
}
}
return
}
|
go
|
func (c *Chunk) ParseStringTable(reader io.ReadSeeker) {
strOffset := int32(0)
for i := int64(0); i < sizeStringBucket*4; i += 4 {
encoding.Unmarshal(reader, &strOffset, Endianness)
if strOffset > 0 {
cs, err := StringAt(reader, int64(strOffset))
if err != nil {
if !ModeCarving {
panic(err)
}
}
c.StringTable[strOffset] = cs
}
}
return
}
|
[
"func",
"(",
"c",
"*",
"Chunk",
")",
"ParseStringTable",
"(",
"reader",
"io",
".",
"ReadSeeker",
")",
"{",
"strOffset",
":=",
"int32",
"(",
"0",
")",
"\n",
"for",
"i",
":=",
"int64",
"(",
"0",
")",
";",
"i",
"<",
"sizeStringBucket",
"*",
"4",
";",
"i",
"+=",
"4",
"{",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"strOffset",
",",
"Endianness",
")",
"\n",
"if",
"strOffset",
">",
"0",
"{",
"cs",
",",
"err",
":=",
"StringAt",
"(",
"reader",
",",
"int64",
"(",
"strOffset",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"!",
"ModeCarving",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"c",
".",
"StringTable",
"[",
"strOffset",
"]",
"=",
"cs",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// ParseStringTable parses the string table located at the current offset in the
// reader and modify the chunk object
// @reader : reader object to parse string table from
|
[
"ParseStringTable",
"parses",
"the",
"string",
"table",
"located",
"at",
"the",
"current",
"offset",
"in",
"the",
"reader",
"and",
"modify",
"the",
"chunk",
"object"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L127-L142
|
17,437 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
ParseTemplateTable
|
func (c *Chunk) ParseTemplateTable(reader io.ReadSeeker) error {
templateDataOffset := int32(0)
for i := int32(0); i < sizeTemplateBucket*4; i = i + 4 {
//parse(buf, i, &tempOffsetTable[j])
err := encoding.Unmarshal(reader, &templateDataOffset, Endianness)
if err != nil {
// panic(err)
log.DebugDontPanic(err)
return err
}
if templateDataOffset > 0 {
backup := BackupSeeker(reader)
// We arrive in template data, we have to do some offset patching in order to get
// back to TemplateInstance token and make it easily parsable by binxml.Parse
GoToSeeker(reader, int64(templateDataOffset))
tdd := TemplateDefinitionData{}
err := tdd.Parse(reader)
if err != nil {
//panic(err)
log.DebugDontPanic(err)
return err
}
c.TemplateTable[templateDataOffset] = tdd
GoToSeeker(reader, backup)
}
}
return nil
}
|
go
|
func (c *Chunk) ParseTemplateTable(reader io.ReadSeeker) error {
templateDataOffset := int32(0)
for i := int32(0); i < sizeTemplateBucket*4; i = i + 4 {
//parse(buf, i, &tempOffsetTable[j])
err := encoding.Unmarshal(reader, &templateDataOffset, Endianness)
if err != nil {
// panic(err)
log.DebugDontPanic(err)
return err
}
if templateDataOffset > 0 {
backup := BackupSeeker(reader)
// We arrive in template data, we have to do some offset patching in order to get
// back to TemplateInstance token and make it easily parsable by binxml.Parse
GoToSeeker(reader, int64(templateDataOffset))
tdd := TemplateDefinitionData{}
err := tdd.Parse(reader)
if err != nil {
//panic(err)
log.DebugDontPanic(err)
return err
}
c.TemplateTable[templateDataOffset] = tdd
GoToSeeker(reader, backup)
}
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Chunk",
")",
"ParseTemplateTable",
"(",
"reader",
"io",
".",
"ReadSeeker",
")",
"error",
"{",
"templateDataOffset",
":=",
"int32",
"(",
"0",
")",
"\n",
"for",
"i",
":=",
"int32",
"(",
"0",
")",
";",
"i",
"<",
"sizeTemplateBucket",
"*",
"4",
";",
"i",
"=",
"i",
"+",
"4",
"{",
"//parse(buf, i, &tempOffsetTable[j])",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"templateDataOffset",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// panic(err)",
"log",
".",
"DebugDontPanic",
"(",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"if",
"templateDataOffset",
">",
"0",
"{",
"backup",
":=",
"BackupSeeker",
"(",
"reader",
")",
"\n",
"// We arrive in template data, we have to do some offset patching in order to get",
"// back to TemplateInstance token and make it easily parsable by binxml.Parse",
"GoToSeeker",
"(",
"reader",
",",
"int64",
"(",
"templateDataOffset",
")",
")",
"\n",
"tdd",
":=",
"TemplateDefinitionData",
"{",
"}",
"\n",
"err",
":=",
"tdd",
".",
"Parse",
"(",
"reader",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"//panic(err)",
"log",
".",
"DebugDontPanic",
"(",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"c",
".",
"TemplateTable",
"[",
"templateDataOffset",
"]",
"=",
"tdd",
"\n",
"GoToSeeker",
"(",
"reader",
",",
"backup",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ParseTemplaTable parses the template table located at the current offset in
// the reader passed as parameter and modifies the current Chunk object
// @reader : reader object to parse string table from
|
[
"ParseTemplaTable",
"parses",
"the",
"template",
"table",
"located",
"at",
"the",
"current",
"offset",
"in",
"the",
"reader",
"passed",
"as",
"parameter",
"and",
"modifies",
"the",
"current",
"Chunk",
"object"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L147-L174
|
17,438 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
ParseEventOffsets
|
func (c *Chunk) ParseEventOffsets(reader io.ReadSeeker) (err error) {
c.EventOffsets = make([]int32, 0)
offsetEvent := int32(BackupSeeker(reader))
c.EventOffsets = append(c.EventOffsets, offsetEvent)
for offsetEvent <= c.Header.OffsetLastRec {
eh := EventHeader{}
GoToSeeker(reader, int64(offsetEvent))
if err = encoding.Unmarshal(reader, &eh, Endianness); err != nil {
log.DebugDontPanic(err)
return err
}
// Event Header is not valid
if err = eh.Validate(); err != nil {
// we bruteforce in carving mode
if ModeCarving {
offsetEvent++
continue
}
return err
}
offsetEvent += eh.Size
c.EventOffsets = append(c.EventOffsets, offsetEvent)
}
return nil
}
|
go
|
func (c *Chunk) ParseEventOffsets(reader io.ReadSeeker) (err error) {
c.EventOffsets = make([]int32, 0)
offsetEvent := int32(BackupSeeker(reader))
c.EventOffsets = append(c.EventOffsets, offsetEvent)
for offsetEvent <= c.Header.OffsetLastRec {
eh := EventHeader{}
GoToSeeker(reader, int64(offsetEvent))
if err = encoding.Unmarshal(reader, &eh, Endianness); err != nil {
log.DebugDontPanic(err)
return err
}
// Event Header is not valid
if err = eh.Validate(); err != nil {
// we bruteforce in carving mode
if ModeCarving {
offsetEvent++
continue
}
return err
}
offsetEvent += eh.Size
c.EventOffsets = append(c.EventOffsets, offsetEvent)
}
return nil
}
|
[
"func",
"(",
"c",
"*",
"Chunk",
")",
"ParseEventOffsets",
"(",
"reader",
"io",
".",
"ReadSeeker",
")",
"(",
"err",
"error",
")",
"{",
"c",
".",
"EventOffsets",
"=",
"make",
"(",
"[",
"]",
"int32",
",",
"0",
")",
"\n",
"offsetEvent",
":=",
"int32",
"(",
"BackupSeeker",
"(",
"reader",
")",
")",
"\n",
"c",
".",
"EventOffsets",
"=",
"append",
"(",
"c",
".",
"EventOffsets",
",",
"offsetEvent",
")",
"\n",
"for",
"offsetEvent",
"<=",
"c",
".",
"Header",
".",
"OffsetLastRec",
"{",
"eh",
":=",
"EventHeader",
"{",
"}",
"\n",
"GoToSeeker",
"(",
"reader",
",",
"int64",
"(",
"offsetEvent",
")",
")",
"\n",
"if",
"err",
"=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"eh",
",",
"Endianness",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"DebugDontPanic",
"(",
"err",
")",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"// Event Header is not valid",
"if",
"err",
"=",
"eh",
".",
"Validate",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"// we bruteforce in carving mode",
"if",
"ModeCarving",
"{",
"offsetEvent",
"++",
"\n",
"continue",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n",
"offsetEvent",
"+=",
"eh",
".",
"Size",
"\n",
"c",
".",
"EventOffsets",
"=",
"append",
"(",
"c",
".",
"EventOffsets",
",",
"offsetEvent",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// ParseEventOffsets parses the offsets at which we can find the events and
// modifies the current Chunk object
// @reader : reader object to parse event offsets from
|
[
"ParseEventOffsets",
"parses",
"the",
"offsets",
"at",
"which",
"we",
"can",
"find",
"the",
"events",
"and",
"modifies",
"the",
"current",
"Chunk",
"object"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L179-L203
|
17,439 |
0xrawsec/golang-evtx
|
evtx/chunk.go
|
ParseEvent
|
func (c *Chunk) ParseEvent(offset int64) (e Event) {
if int64(c.Header.OffsetLastRec) < offset {
return
}
reader := bytes.NewReader(c.Data)
GoToSeeker(reader, offset)
e.Offset = offset
err := encoding.Unmarshal(reader, &e.Header, Endianness)
if err != nil {
panic(err)
}
/*err := encoding.Unmarshal(reader, &e.Magic, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.Size, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.ID, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.Timestamp, Endianness)
if err != nil {
panic(err)
}*/
return e
}
|
go
|
func (c *Chunk) ParseEvent(offset int64) (e Event) {
if int64(c.Header.OffsetLastRec) < offset {
return
}
reader := bytes.NewReader(c.Data)
GoToSeeker(reader, offset)
e.Offset = offset
err := encoding.Unmarshal(reader, &e.Header, Endianness)
if err != nil {
panic(err)
}
/*err := encoding.Unmarshal(reader, &e.Magic, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.Size, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.ID, Endianness)
if err != nil {
panic(err)
}
err = encoding.Unmarshal(reader, &e.Timestamp, Endianness)
if err != nil {
panic(err)
}*/
return e
}
|
[
"func",
"(",
"c",
"*",
"Chunk",
")",
"ParseEvent",
"(",
"offset",
"int64",
")",
"(",
"e",
"Event",
")",
"{",
"if",
"int64",
"(",
"c",
".",
"Header",
".",
"OffsetLastRec",
")",
"<",
"offset",
"{",
"return",
"\n",
"}",
"\n",
"reader",
":=",
"bytes",
".",
"NewReader",
"(",
"c",
".",
"Data",
")",
"\n",
"GoToSeeker",
"(",
"reader",
",",
"offset",
")",
"\n",
"e",
".",
"Offset",
"=",
"offset",
"\n",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"e",
".",
"Header",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n",
"/*err := encoding.Unmarshal(reader, &e.Magic, Endianness)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\terr = encoding.Unmarshal(reader, &e.Size, Endianness)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\terr = encoding.Unmarshal(reader, &e.ID, Endianness)\n\tif err != nil {\n\t\tpanic(err)\n\t}\n\terr = encoding.Unmarshal(reader, &e.Timestamp, Endianness)\n\tif err != nil {\n\t\tpanic(err)\n\t}*/",
"return",
"e",
"\n",
"}"
] |
// ParseEvent parses an Event from the current chunk located at the relative
// offset in c.Data, does not alter the current Chunk structure
// @offset : offset to parse the Event at
// return Event : parsed Event
|
[
"ParseEvent",
"parses",
"an",
"Event",
"from",
"the",
"current",
"chunk",
"located",
"at",
"the",
"relative",
"offset",
"in",
"c",
".",
"Data",
"does",
"not",
"alter",
"the",
"current",
"Chunk",
"structure"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/chunk.go#L209-L237
|
17,440 |
0xrawsec/golang-evtx
|
evtx/structs.go
|
Parse
|
func (e *BinXMLEntityReference) Parse(reader io.ReadSeeker) error {
err := encoding.Unmarshal(reader, &e.Token, Endianness)
if err != nil {
return err
}
err = encoding.Unmarshal(reader, &e.NameOffset, Endianness)
if err != nil {
return err
}
o := BackupSeeker(reader)
// if the Entity Name is just after
if int64(e.NameOffset) == o {
return e.Name.Parse(reader)
}
// We jump to the right offset
GoToSeeker(reader, int64(e.NameOffset))
err = e.Name.Parse(reader)
// We restore our position
GoToSeeker(reader, o)
return err
}
|
go
|
func (e *BinXMLEntityReference) Parse(reader io.ReadSeeker) error {
err := encoding.Unmarshal(reader, &e.Token, Endianness)
if err != nil {
return err
}
err = encoding.Unmarshal(reader, &e.NameOffset, Endianness)
if err != nil {
return err
}
o := BackupSeeker(reader)
// if the Entity Name is just after
if int64(e.NameOffset) == o {
return e.Name.Parse(reader)
}
// We jump to the right offset
GoToSeeker(reader, int64(e.NameOffset))
err = e.Name.Parse(reader)
// We restore our position
GoToSeeker(reader, o)
return err
}
|
[
"func",
"(",
"e",
"*",
"BinXMLEntityReference",
")",
"Parse",
"(",
"reader",
"io",
".",
"ReadSeeker",
")",
"error",
"{",
"err",
":=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"e",
".",
"Token",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"encoding",
".",
"Unmarshal",
"(",
"reader",
",",
"&",
"e",
".",
"NameOffset",
",",
"Endianness",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"o",
":=",
"BackupSeeker",
"(",
"reader",
")",
"\n",
"// if the Entity Name is just after",
"if",
"int64",
"(",
"e",
".",
"NameOffset",
")",
"==",
"o",
"{",
"return",
"e",
".",
"Name",
".",
"Parse",
"(",
"reader",
")",
"\n",
"}",
"\n",
"// We jump to the right offset",
"GoToSeeker",
"(",
"reader",
",",
"int64",
"(",
"e",
".",
"NameOffset",
")",
")",
"\n",
"err",
"=",
"e",
".",
"Name",
".",
"Parse",
"(",
"reader",
")",
"\n",
"// We restore our position",
"GoToSeeker",
"(",
"reader",
",",
"o",
")",
"\n",
"return",
"err",
"\n",
"}"
] |
// Parse implements Element
|
[
"Parse",
"implements",
"Element"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/structs.go#L852-L872
|
17,441 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
Get
|
func (pg *GoEvtxMap) Get(path *GoEvtxPath) (*GoEvtxElement, error) {
if len(*path) > 0 {
if i, ok := (*pg)[(*path)[0]]; ok {
if len(*path) == 1 {
cge := GoEvtxElement(i)
return &cge, nil
}
switch i.(type) {
case GoEvtxMap:
p := i.(GoEvtxMap)
np := (*path)[1:]
return p.Get(&np)
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Get(&np)
}
}
}
return nil, &ErrEvtxEltNotFound{*path}
}
|
go
|
func (pg *GoEvtxMap) Get(path *GoEvtxPath) (*GoEvtxElement, error) {
if len(*path) > 0 {
if i, ok := (*pg)[(*path)[0]]; ok {
if len(*path) == 1 {
cge := GoEvtxElement(i)
return &cge, nil
}
switch i.(type) {
case GoEvtxMap:
p := i.(GoEvtxMap)
np := (*path)[1:]
return p.Get(&np)
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Get(&np)
}
}
}
return nil, &ErrEvtxEltNotFound{*path}
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"Get",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"*",
"GoEvtxElement",
",",
"error",
")",
"{",
"if",
"len",
"(",
"*",
"path",
")",
">",
"0",
"{",
"if",
"i",
",",
"ok",
":=",
"(",
"*",
"pg",
")",
"[",
"(",
"*",
"path",
")",
"[",
"0",
"]",
"]",
";",
"ok",
"{",
"if",
"len",
"(",
"*",
"path",
")",
"==",
"1",
"{",
"cge",
":=",
"GoEvtxElement",
"(",
"i",
")",
"\n",
"return",
"&",
"cge",
",",
"nil",
"\n",
"}",
"\n",
"switch",
"i",
".",
"(",
"type",
")",
"{",
"case",
"GoEvtxMap",
":",
"p",
":=",
"i",
".",
"(",
"GoEvtxMap",
")",
"\n",
"np",
":=",
"(",
"*",
"path",
")",
"[",
"1",
":",
"]",
"\n",
"return",
"p",
".",
"Get",
"(",
"&",
"np",
")",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"p",
":=",
"GoEvtxMap",
"(",
"i",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
")",
"\n",
"np",
":=",
"(",
"*",
"path",
")",
"[",
"1",
":",
"]",
"\n",
"return",
"p",
".",
"Get",
"(",
"&",
"np",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"nil",
",",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}"
] |
// Recursive search in a GoEvtxMap according to a given path
// @path : path to search for
// return *GoEvtxElement, error : pointer to the element found at path
|
[
"Recursive",
"search",
"in",
"a",
"GoEvtxMap",
"according",
"to",
"a",
"given",
"path"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L111-L131
|
17,442 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
GetString
|
func (pg *GoEvtxMap) GetString(path *GoEvtxPath) (string, error) {
pE, err := pg.Get(path)
if err != nil {
return "", err
}
if s, ok := (*pE).(string); ok {
return s, nil
}
return "", fmt.Errorf("Bad type expect string got %T", (*pE))
}
|
go
|
func (pg *GoEvtxMap) GetString(path *GoEvtxPath) (string, error) {
pE, err := pg.Get(path)
if err != nil {
return "", err
}
if s, ok := (*pE).(string); ok {
return s, nil
}
return "", fmt.Errorf("Bad type expect string got %T", (*pE))
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"GetString",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"string",
",",
"error",
")",
"{",
"pE",
",",
"err",
":=",
"pg",
".",
"Get",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"s",
",",
"ok",
":=",
"(",
"*",
"pE",
")",
".",
"(",
"string",
")",
";",
"ok",
"{",
"return",
"s",
",",
"nil",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"(",
"*",
"pE",
")",
")",
"\n",
"}"
] |
// GetUint returns the GoEvtxElement at path as a string
// @path : path to search for
// return string, error
|
[
"GetUint",
"returns",
"the",
"GoEvtxElement",
"at",
"path",
"as",
"a",
"string"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L144-L153
|
17,443 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
GetBool
|
func (pg *GoEvtxMap) GetBool(path *GoEvtxPath) (bool, error) {
s, err := pg.GetString(path)
if err != nil {
return false, &ErrEvtxEltNotFound{*path}
}
b, err := strconv.ParseBool(s)
if err != nil {
return false, err
}
return b, err
}
|
go
|
func (pg *GoEvtxMap) GetBool(path *GoEvtxPath) (bool, error) {
s, err := pg.GetString(path)
if err != nil {
return false, &ErrEvtxEltNotFound{*path}
}
b, err := strconv.ParseBool(s)
if err != nil {
return false, err
}
return b, err
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"GetBool",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"bool",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"pg",
".",
"GetString",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}",
"\n",
"b",
",",
"err",
":=",
"strconv",
".",
"ParseBool",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"return",
"b",
",",
"err",
"\n",
"}"
] |
// GetBool returns the GoEvtxElement at path as a bool
// @path : path to search for
// return (bool, error)
|
[
"GetBool",
"returns",
"the",
"GoEvtxElement",
"at",
"path",
"as",
"a",
"bool"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L166-L176
|
17,444 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
GetInt
|
func (pg *GoEvtxMap) GetInt(path *GoEvtxPath) (int64, error) {
s, err := pg.GetString(path)
if err != nil {
return 0, &ErrEvtxEltNotFound{*path}
}
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return 0, err
}
return i, nil
}
|
go
|
func (pg *GoEvtxMap) GetInt(path *GoEvtxPath) (int64, error) {
s, err := pg.GetString(path)
if err != nil {
return 0, &ErrEvtxEltNotFound{*path}
}
i, err := strconv.ParseInt(s, 10, 64)
if err != nil {
return 0, err
}
return i, nil
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"GetInt",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"int64",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"pg",
".",
"GetString",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}",
"\n",
"i",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"s",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"i",
",",
"nil",
"\n",
"}"
] |
// GetInt returns the GoEvtxElement at path as a int64
// @path : path to search for
// return int64, error
|
[
"GetInt",
"returns",
"the",
"GoEvtxElement",
"at",
"path",
"as",
"a",
"int64"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L189-L199
|
17,445 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
GetUint
|
func (pg *GoEvtxMap) GetUint(path *GoEvtxPath) (uint64, error) {
s, err := pg.GetString(path)
if err != nil {
return 0, &ErrEvtxEltNotFound{*path}
}
u, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return 0, err
}
return u, nil
}
|
go
|
func (pg *GoEvtxMap) GetUint(path *GoEvtxPath) (uint64, error) {
s, err := pg.GetString(path)
if err != nil {
return 0, &ErrEvtxEltNotFound{*path}
}
u, err := strconv.ParseUint(s, 10, 64)
if err != nil {
return 0, err
}
return u, nil
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"GetUint",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"pg",
".",
"GetString",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"strconv",
".",
"ParseUint",
"(",
"s",
",",
"10",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"0",
",",
"err",
"\n",
"}",
"\n",
"return",
"u",
",",
"nil",
"\n",
"}"
] |
// GetUint returns the GoEvtxElement at path as a uint64
// @path : path to search for
// return uint64
|
[
"GetUint",
"returns",
"the",
"GoEvtxElement",
"at",
"path",
"as",
"a",
"uint64"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L212-L222
|
17,446 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
GetTime
|
func (pg *GoEvtxMap) GetTime(path *GoEvtxPath) (time.Time, error) {
t, err := pg.Get(path)
if err != nil {
return time.Time{}, &ErrEvtxEltNotFound{*path}
}
// If the value was extracted from raw BinXML (not a template) it may happen
// that the value stored at path is a string since in raw BinXML everything
// seems to be ValueText
switch (*t).(type) {
case time.Time:
return (*t).(time.Time), nil
case UTCTime:
return time.Time((*t).(UTCTime)), nil
case string:
return time.Parse(time.RFC3339Nano, (*t).(string))
default:
return time.Time{}, fmt.Errorf("Cannot convert %T to time.Time", *t)
}
}
|
go
|
func (pg *GoEvtxMap) GetTime(path *GoEvtxPath) (time.Time, error) {
t, err := pg.Get(path)
if err != nil {
return time.Time{}, &ErrEvtxEltNotFound{*path}
}
// If the value was extracted from raw BinXML (not a template) it may happen
// that the value stored at path is a string since in raw BinXML everything
// seems to be ValueText
switch (*t).(type) {
case time.Time:
return (*t).(time.Time), nil
case UTCTime:
return time.Time((*t).(UTCTime)), nil
case string:
return time.Parse(time.RFC3339Nano, (*t).(string))
default:
return time.Time{}, fmt.Errorf("Cannot convert %T to time.Time", *t)
}
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"GetTime",
"(",
"path",
"*",
"GoEvtxPath",
")",
"(",
"time",
".",
"Time",
",",
"error",
")",
"{",
"t",
",",
"err",
":=",
"pg",
".",
"Get",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
",",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}",
"\n",
"// If the value was extracted from raw BinXML (not a template) it may happen",
"// that the value stored at path is a string since in raw BinXML everything",
"// seems to be ValueText",
"switch",
"(",
"*",
"t",
")",
".",
"(",
"type",
")",
"{",
"case",
"time",
".",
"Time",
":",
"return",
"(",
"*",
"t",
")",
".",
"(",
"time",
".",
"Time",
")",
",",
"nil",
"\n",
"case",
"UTCTime",
":",
"return",
"time",
".",
"Time",
"(",
"(",
"*",
"t",
")",
".",
"(",
"UTCTime",
")",
")",
",",
"nil",
"\n",
"case",
"string",
":",
"return",
"time",
".",
"Parse",
"(",
"time",
".",
"RFC3339Nano",
",",
"(",
"*",
"t",
")",
".",
"(",
"string",
")",
")",
"\n",
"default",
":",
"return",
"time",
".",
"Time",
"{",
"}",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"*",
"t",
")",
"\n",
"}",
"\n",
"}"
] |
// GetUint returns the GoEvtxElement at path as a Time struct
// @path : path to search for
// return Time
|
[
"GetUint",
"returns",
"the",
"GoEvtxElement",
"at",
"path",
"as",
"a",
"Time",
"struct"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L235-L253
|
17,447 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
Equal
|
func (pg *GoEvtxMap) Equal(path *GoEvtxPath, i interface{}) bool {
t, err := pg.Get(path)
if err != nil {
return false
}
return reflect.DeepEqual(*t, i)
}
|
go
|
func (pg *GoEvtxMap) Equal(path *GoEvtxPath, i interface{}) bool {
t, err := pg.Get(path)
if err != nil {
return false
}
return reflect.DeepEqual(*t, i)
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"Equal",
"(",
"path",
"*",
"GoEvtxPath",
",",
"i",
"interface",
"{",
"}",
")",
"bool",
"{",
"t",
",",
"err",
":=",
"pg",
".",
"Get",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"reflect",
".",
"DeepEqual",
"(",
"*",
"t",
",",
"i",
")",
"\n",
"}"
] |
// Equal returns true if element at path is equal to i
// @path : path at witch GoEvtxElement is located
// @i : interface to test equality with
// return bool : true if equality is verified
|
[
"Equal",
"returns",
"true",
"if",
"element",
"at",
"path",
"is",
"equal",
"to",
"i"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L325-L331
|
17,448 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
AnyEqual
|
func (pg *GoEvtxMap) AnyEqual(path *GoEvtxPath, is []interface{}) bool {
t, err := pg.Get(path)
if err != nil {
return false
}
for _, i := range is {
if reflect.DeepEqual(i, *t) {
return true
}
}
return false
}
|
go
|
func (pg *GoEvtxMap) AnyEqual(path *GoEvtxPath, is []interface{}) bool {
t, err := pg.Get(path)
if err != nil {
return false
}
for _, i := range is {
if reflect.DeepEqual(i, *t) {
return true
}
}
return false
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"AnyEqual",
"(",
"path",
"*",
"GoEvtxPath",
",",
"is",
"[",
"]",
"interface",
"{",
"}",
")",
"bool",
"{",
"t",
",",
"err",
":=",
"pg",
".",
"Get",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"is",
"{",
"if",
"reflect",
".",
"DeepEqual",
"(",
"i",
",",
"*",
"t",
")",
"{",
"return",
"true",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"false",
"\n",
"}"
] |
// Equal returns true if element at path is equal to any object
// @path : path at witch GoEvtxElement is located
// @is : slice of interface to test equality with
// return bool : true if equality is verified
|
[
"Equal",
"returns",
"true",
"if",
"element",
"at",
"path",
"is",
"equal",
"to",
"any",
"object"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L337-L348
|
17,449 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
RegexMatch
|
func (pg *GoEvtxMap) RegexMatch(path *GoEvtxPath, pattern *regexp.Regexp) bool {
s, err := pg.GetString(path)
if err != nil {
return false
}
return pattern.MatchString(s)
}
|
go
|
func (pg *GoEvtxMap) RegexMatch(path *GoEvtxPath, pattern *regexp.Regexp) bool {
s, err := pg.GetString(path)
if err != nil {
return false
}
return pattern.MatchString(s)
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"RegexMatch",
"(",
"path",
"*",
"GoEvtxPath",
",",
"pattern",
"*",
"regexp",
".",
"Regexp",
")",
"bool",
"{",
"s",
",",
"err",
":=",
"pg",
".",
"GetString",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"pattern",
".",
"MatchString",
"(",
"s",
")",
"\n",
"}"
] |
// RegexMatch returns true if GoEvtxElement located at path matches a regexp
// @path : path at witch GoEvtxElement is located
// @pattern : regexp to test
// return bool
|
[
"RegexMatch",
"returns",
"true",
"if",
"GoEvtxElement",
"located",
"at",
"path",
"matches",
"a",
"regexp"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L354-L360
|
17,450 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
Set
|
func (pg *GoEvtxMap) Set(path *GoEvtxPath, new GoEvtxElement) error {
if len(*path) > 0 {
i := (*pg)[(*path)[0]]
if len(*path) == 1 {
(*pg)[(*path)[0]] = new
return nil
}
switch i.(type) {
case GoEvtxMap:
p := i.(GoEvtxMap)
np := (*path)[1:]
return p.Set(&np, new)
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Set(&np, new)
}
}
return &ErrEvtxEltNotFound{*path}
}
|
go
|
func (pg *GoEvtxMap) Set(path *GoEvtxPath, new GoEvtxElement) error {
if len(*path) > 0 {
i := (*pg)[(*path)[0]]
if len(*path) == 1 {
(*pg)[(*path)[0]] = new
return nil
}
switch i.(type) {
case GoEvtxMap:
p := i.(GoEvtxMap)
np := (*path)[1:]
return p.Set(&np, new)
case map[string]interface{}:
p := GoEvtxMap(i.(map[string]interface{}))
np := (*path)[1:]
return p.Set(&np, new)
}
}
return &ErrEvtxEltNotFound{*path}
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"Set",
"(",
"path",
"*",
"GoEvtxPath",
",",
"new",
"GoEvtxElement",
")",
"error",
"{",
"if",
"len",
"(",
"*",
"path",
")",
">",
"0",
"{",
"i",
":=",
"(",
"*",
"pg",
")",
"[",
"(",
"*",
"path",
")",
"[",
"0",
"]",
"]",
"\n",
"if",
"len",
"(",
"*",
"path",
")",
"==",
"1",
"{",
"(",
"*",
"pg",
")",
"[",
"(",
"*",
"path",
")",
"[",
"0",
"]",
"]",
"=",
"new",
"\n",
"return",
"nil",
"\n",
"}",
"\n",
"switch",
"i",
".",
"(",
"type",
")",
"{",
"case",
"GoEvtxMap",
":",
"p",
":=",
"i",
".",
"(",
"GoEvtxMap",
")",
"\n",
"np",
":=",
"(",
"*",
"path",
")",
"[",
"1",
":",
"]",
"\n",
"return",
"p",
".",
"Set",
"(",
"&",
"np",
",",
"new",
")",
"\n",
"case",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
":",
"p",
":=",
"GoEvtxMap",
"(",
"i",
".",
"(",
"map",
"[",
"string",
"]",
"interface",
"{",
"}",
")",
")",
"\n",
"np",
":=",
"(",
"*",
"path",
")",
"[",
"1",
":",
"]",
"\n",
"return",
"p",
".",
"Set",
"(",
"&",
"np",
",",
"new",
")",
"\n",
"}",
"\n\n",
"}",
"\n",
"return",
"&",
"ErrEvtxEltNotFound",
"{",
"*",
"path",
"}",
"\n",
"}"
] |
// Set sets a new GoEvtxElement at path
// @path... : path to look for
// @new : new value
// return error if any
|
[
"Set",
"sets",
"a",
"new",
"GoEvtxElement",
"at",
"path"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L373-L393
|
17,451 |
0xrawsec/golang-evtx
|
evtx/goevtx.go
|
Del
|
func (pg *GoEvtxMap) Del(path ...string) {
if len(path) > 0 {
if ge, ok := (*pg)[path[0]]; ok {
if len(path) == 1 {
delete((*pg), path[0])
}
switch ge.(type) {
case GoEvtxMap:
p := ge.(GoEvtxMap)
p.Del(path[1:]...)
}
}
}
}
|
go
|
func (pg *GoEvtxMap) Del(path ...string) {
if len(path) > 0 {
if ge, ok := (*pg)[path[0]]; ok {
if len(path) == 1 {
delete((*pg), path[0])
}
switch ge.(type) {
case GoEvtxMap:
p := ge.(GoEvtxMap)
p.Del(path[1:]...)
}
}
}
}
|
[
"func",
"(",
"pg",
"*",
"GoEvtxMap",
")",
"Del",
"(",
"path",
"...",
"string",
")",
"{",
"if",
"len",
"(",
"path",
")",
">",
"0",
"{",
"if",
"ge",
",",
"ok",
":=",
"(",
"*",
"pg",
")",
"[",
"path",
"[",
"0",
"]",
"]",
";",
"ok",
"{",
"if",
"len",
"(",
"path",
")",
"==",
"1",
"{",
"delete",
"(",
"(",
"*",
"pg",
")",
",",
"path",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"switch",
"ge",
".",
"(",
"type",
")",
"{",
"case",
"GoEvtxMap",
":",
"p",
":=",
"ge",
".",
"(",
"GoEvtxMap",
")",
"\n",
"p",
".",
"Del",
"(",
"path",
"[",
"1",
":",
"]",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
// Del deletes the object referenced by path
|
[
"Del",
"deletes",
"the",
"object",
"referenced",
"by",
"path"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/goevtx.go#L396-L409
|
17,452 |
0xrawsec/golang-evtx
|
evtx/event.go
|
Validate
|
func (h *EventHeader) Validate() error {
// Validate the event magic
if string(h.Magic[:]) != EventMagic {
return fmt.Errorf("Bad event magic %q", h.Magic)
}
// An event cannot be bigger than a Chunk since an event is embedded into a
// chunk
if h.Size >= ChunkSize {
return fmt.Errorf("Too big event")
}
// An event cannot be smaller than its header since the event size include the
// size of the header
if h.Size < EventHeaderSize {
return fmt.Errorf("Too small event")
}
return nil
}
|
go
|
func (h *EventHeader) Validate() error {
// Validate the event magic
if string(h.Magic[:]) != EventMagic {
return fmt.Errorf("Bad event magic %q", h.Magic)
}
// An event cannot be bigger than a Chunk since an event is embedded into a
// chunk
if h.Size >= ChunkSize {
return fmt.Errorf("Too big event")
}
// An event cannot be smaller than its header since the event size include the
// size of the header
if h.Size < EventHeaderSize {
return fmt.Errorf("Too small event")
}
return nil
}
|
[
"func",
"(",
"h",
"*",
"EventHeader",
")",
"Validate",
"(",
")",
"error",
"{",
"// Validate the event magic",
"if",
"string",
"(",
"h",
".",
"Magic",
"[",
":",
"]",
")",
"!=",
"EventMagic",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"h",
".",
"Magic",
")",
"\n",
"}",
"\n",
"// An event cannot be bigger than a Chunk since an event is embedded into a",
"// chunk",
"if",
"h",
".",
"Size",
">=",
"ChunkSize",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"// An event cannot be smaller than its header since the event size include the",
"// size of the header",
"if",
"h",
".",
"Size",
"<",
"EventHeaderSize",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// Validate controls the EventHeader
|
[
"Validate",
"controls",
"the",
"EventHeader"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/event.go#L21-L37
|
17,453 |
0xrawsec/golang-evtx
|
evtx/event.go
|
GoEvtxMap
|
func (e Event) GoEvtxMap(c *Chunk) (pge *GoEvtxMap, err error) {
// An Event can contain only BinXMLFragments
if !e.IsValid() {
err = ErrInvalidEvent
return
}
reader := bytes.NewReader(c.Data)
GoToSeeker(reader, e.Offset+EventHeaderSize)
// Bug here if we put c
element, err := Parse(reader, c, false)
if err != nil && err != io.EOF {
//panic(err)
log.Error(err)
}
// If not a BinXMLFragment a panic will be raised
fragment, ok := element.(*Fragment)
switch {
case !ok && ModeCarving:
return
case !ok:
// Way to raise panic
_ = element.(*Fragment)
}
return fragment.GoEvtxMap(), err
}
|
go
|
func (e Event) GoEvtxMap(c *Chunk) (pge *GoEvtxMap, err error) {
// An Event can contain only BinXMLFragments
if !e.IsValid() {
err = ErrInvalidEvent
return
}
reader := bytes.NewReader(c.Data)
GoToSeeker(reader, e.Offset+EventHeaderSize)
// Bug here if we put c
element, err := Parse(reader, c, false)
if err != nil && err != io.EOF {
//panic(err)
log.Error(err)
}
// If not a BinXMLFragment a panic will be raised
fragment, ok := element.(*Fragment)
switch {
case !ok && ModeCarving:
return
case !ok:
// Way to raise panic
_ = element.(*Fragment)
}
return fragment.GoEvtxMap(), err
}
|
[
"func",
"(",
"e",
"Event",
")",
"GoEvtxMap",
"(",
"c",
"*",
"Chunk",
")",
"(",
"pge",
"*",
"GoEvtxMap",
",",
"err",
"error",
")",
"{",
"// An Event can contain only BinXMLFragments",
"if",
"!",
"e",
".",
"IsValid",
"(",
")",
"{",
"err",
"=",
"ErrInvalidEvent",
"\n",
"return",
"\n",
"}",
"\n",
"reader",
":=",
"bytes",
".",
"NewReader",
"(",
"c",
".",
"Data",
")",
"\n",
"GoToSeeker",
"(",
"reader",
",",
"e",
".",
"Offset",
"+",
"EventHeaderSize",
")",
"\n",
"// Bug here if we put c",
"element",
",",
"err",
":=",
"Parse",
"(",
"reader",
",",
"c",
",",
"false",
")",
"\n",
"if",
"err",
"!=",
"nil",
"&&",
"err",
"!=",
"io",
".",
"EOF",
"{",
"//panic(err)",
"log",
".",
"Error",
"(",
"err",
")",
"\n",
"}",
"\n",
"// If not a BinXMLFragment a panic will be raised",
"fragment",
",",
"ok",
":=",
"element",
".",
"(",
"*",
"Fragment",
")",
"\n",
"switch",
"{",
"case",
"!",
"ok",
"&&",
"ModeCarving",
":",
"return",
"\n",
"case",
"!",
"ok",
":",
"// Way to raise panic",
"_",
"=",
"element",
".",
"(",
"*",
"Fragment",
")",
"\n",
"}",
"\n",
"return",
"fragment",
".",
"GoEvtxMap",
"(",
")",
",",
"err",
"\n",
"}"
] |
// GoEvtxMap parses the BinXML inside the event and returns a pointer to a
// structure GoEvtxMap
// @c : chunk pointer used for template data already parsed
// return (*GoEvtxMap, error)
|
[
"GoEvtxMap",
"parses",
"the",
"BinXML",
"inside",
"the",
"event",
"and",
"returns",
"a",
"pointer",
"to",
"a",
"structure",
"GoEvtxMap"
] |
69fdb30898d69884050cc2b2fd2f541274e38bba
|
https://github.com/0xrawsec/golang-evtx/blob/69fdb30898d69884050cc2b2fd2f541274e38bba/evtx/event.go#L56-L80
|
17,454 |
go-xorm/core
|
index.go
|
AddColumn
|
func (index *Index) AddColumn(cols ...string) {
for _, col := range cols {
index.Cols = append(index.Cols, col)
}
}
|
go
|
func (index *Index) AddColumn(cols ...string) {
for _, col := range cols {
index.Cols = append(index.Cols, col)
}
}
|
[
"func",
"(",
"index",
"*",
"Index",
")",
"AddColumn",
"(",
"cols",
"...",
"string",
")",
"{",
"for",
"_",
",",
"col",
":=",
"range",
"cols",
"{",
"index",
".",
"Cols",
"=",
"append",
"(",
"index",
".",
"Cols",
",",
"col",
")",
"\n",
"}",
"\n",
"}"
] |
// add columns which will be composite index
|
[
"add",
"columns",
"which",
"will",
"be",
"composite",
"index"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/index.go#L39-L43
|
17,455 |
go-xorm/core
|
index.go
|
NewIndex
|
func NewIndex(name string, indexType int) *Index {
return &Index{true, name, indexType, make([]string, 0)}
}
|
go
|
func NewIndex(name string, indexType int) *Index {
return &Index{true, name, indexType, make([]string, 0)}
}
|
[
"func",
"NewIndex",
"(",
"name",
"string",
",",
"indexType",
"int",
")",
"*",
"Index",
"{",
"return",
"&",
"Index",
"{",
"true",
",",
"name",
",",
"indexType",
",",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"}",
"\n",
"}"
] |
// new an index
|
[
"new",
"an",
"index"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/index.go#L69-L71
|
17,456 |
go-xorm/core
|
type.go
|
Type2SQLType
|
func Type2SQLType(t reflect.Type) (st SQLType) {
switch k := t.Kind(); k {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
st = SQLType{Int, 0, 0}
case reflect.Int64, reflect.Uint64:
st = SQLType{BigInt, 0, 0}
case reflect.Float32:
st = SQLType{Float, 0, 0}
case reflect.Float64:
st = SQLType{Double, 0, 0}
case reflect.Complex64, reflect.Complex128:
st = SQLType{Varchar, 64, 0}
case reflect.Array, reflect.Slice, reflect.Map:
if t.Elem() == reflect.TypeOf(c_BYTE_DEFAULT) {
st = SQLType{Blob, 0, 0}
} else {
st = SQLType{Text, 0, 0}
}
case reflect.Bool:
st = SQLType{Bool, 0, 0}
case reflect.String:
st = SQLType{Varchar, 255, 0}
case reflect.Struct:
if t.ConvertibleTo(TimeType) {
st = SQLType{DateTime, 0, 0}
} else {
// TODO need to handle association struct
st = SQLType{Text, 0, 0}
}
case reflect.Ptr:
st = Type2SQLType(t.Elem())
default:
st = SQLType{Text, 0, 0}
}
return
}
|
go
|
func Type2SQLType(t reflect.Type) (st SQLType) {
switch k := t.Kind(); k {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32:
st = SQLType{Int, 0, 0}
case reflect.Int64, reflect.Uint64:
st = SQLType{BigInt, 0, 0}
case reflect.Float32:
st = SQLType{Float, 0, 0}
case reflect.Float64:
st = SQLType{Double, 0, 0}
case reflect.Complex64, reflect.Complex128:
st = SQLType{Varchar, 64, 0}
case reflect.Array, reflect.Slice, reflect.Map:
if t.Elem() == reflect.TypeOf(c_BYTE_DEFAULT) {
st = SQLType{Blob, 0, 0}
} else {
st = SQLType{Text, 0, 0}
}
case reflect.Bool:
st = SQLType{Bool, 0, 0}
case reflect.String:
st = SQLType{Varchar, 255, 0}
case reflect.Struct:
if t.ConvertibleTo(TimeType) {
st = SQLType{DateTime, 0, 0}
} else {
// TODO need to handle association struct
st = SQLType{Text, 0, 0}
}
case reflect.Ptr:
st = Type2SQLType(t.Elem())
default:
st = SQLType{Text, 0, 0}
}
return
}
|
[
"func",
"Type2SQLType",
"(",
"t",
"reflect",
".",
"Type",
")",
"(",
"st",
"SQLType",
")",
"{",
"switch",
"k",
":=",
"t",
".",
"Kind",
"(",
")",
";",
"k",
"{",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
":",
"st",
"=",
"SQLType",
"{",
"Int",
",",
"0",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Uint64",
":",
"st",
"=",
"SQLType",
"{",
"BigInt",
",",
"0",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Float32",
":",
"st",
"=",
"SQLType",
"{",
"Float",
",",
"0",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Float64",
":",
"st",
"=",
"SQLType",
"{",
"Double",
",",
"0",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Complex64",
",",
"reflect",
".",
"Complex128",
":",
"st",
"=",
"SQLType",
"{",
"Varchar",
",",
"64",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Array",
",",
"reflect",
".",
"Slice",
",",
"reflect",
".",
"Map",
":",
"if",
"t",
".",
"Elem",
"(",
")",
"==",
"reflect",
".",
"TypeOf",
"(",
"c_BYTE_DEFAULT",
")",
"{",
"st",
"=",
"SQLType",
"{",
"Blob",
",",
"0",
",",
"0",
"}",
"\n",
"}",
"else",
"{",
"st",
"=",
"SQLType",
"{",
"Text",
",",
"0",
",",
"0",
"}",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Bool",
":",
"st",
"=",
"SQLType",
"{",
"Bool",
",",
"0",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"String",
":",
"st",
"=",
"SQLType",
"{",
"Varchar",
",",
"255",
",",
"0",
"}",
"\n",
"case",
"reflect",
".",
"Struct",
":",
"if",
"t",
".",
"ConvertibleTo",
"(",
"TimeType",
")",
"{",
"st",
"=",
"SQLType",
"{",
"DateTime",
",",
"0",
",",
"0",
"}",
"\n",
"}",
"else",
"{",
"// TODO need to handle association struct",
"st",
"=",
"SQLType",
"{",
"Text",
",",
"0",
",",
"0",
"}",
"\n",
"}",
"\n",
"case",
"reflect",
".",
"Ptr",
":",
"st",
"=",
"Type2SQLType",
"(",
"t",
".",
"Elem",
"(",
")",
")",
"\n",
"default",
":",
"st",
"=",
"SQLType",
"{",
"Text",
",",
"0",
",",
"0",
"}",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
// Type2SQLType generate SQLType acorrding Go's type
|
[
"Type2SQLType",
"generate",
"SQLType",
"acorrding",
"Go",
"s",
"type"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/type.go#L261-L296
|
17,457 |
go-xorm/core
|
type.go
|
SQLType2Type
|
func SQLType2Type(st SQLType) reflect.Type {
name := strings.ToUpper(st.Name)
switch name {
case Bit, TinyInt, SmallInt, MediumInt, Int, Integer, Serial:
return reflect.TypeOf(1)
case BigInt, BigSerial:
return reflect.TypeOf(int64(1))
case Float, Real:
return reflect.TypeOf(float32(1))
case Double:
return reflect.TypeOf(float64(1))
case Char, NChar, Varchar, NVarchar, TinyText, Text, NText, MediumText, LongText, Enum, Set, Uuid, Clob, SysName:
return reflect.TypeOf("")
case TinyBlob, Blob, LongBlob, Bytea, Binary, MediumBlob, VarBinary, UniqueIdentifier:
return reflect.TypeOf([]byte{})
case Bool:
return reflect.TypeOf(true)
case DateTime, Date, Time, TimeStamp, TimeStampz, SmallDateTime:
return reflect.TypeOf(c_TIME_DEFAULT)
case Decimal, Numeric, Money, SmallMoney:
return reflect.TypeOf("")
default:
return reflect.TypeOf("")
}
}
|
go
|
func SQLType2Type(st SQLType) reflect.Type {
name := strings.ToUpper(st.Name)
switch name {
case Bit, TinyInt, SmallInt, MediumInt, Int, Integer, Serial:
return reflect.TypeOf(1)
case BigInt, BigSerial:
return reflect.TypeOf(int64(1))
case Float, Real:
return reflect.TypeOf(float32(1))
case Double:
return reflect.TypeOf(float64(1))
case Char, NChar, Varchar, NVarchar, TinyText, Text, NText, MediumText, LongText, Enum, Set, Uuid, Clob, SysName:
return reflect.TypeOf("")
case TinyBlob, Blob, LongBlob, Bytea, Binary, MediumBlob, VarBinary, UniqueIdentifier:
return reflect.TypeOf([]byte{})
case Bool:
return reflect.TypeOf(true)
case DateTime, Date, Time, TimeStamp, TimeStampz, SmallDateTime:
return reflect.TypeOf(c_TIME_DEFAULT)
case Decimal, Numeric, Money, SmallMoney:
return reflect.TypeOf("")
default:
return reflect.TypeOf("")
}
}
|
[
"func",
"SQLType2Type",
"(",
"st",
"SQLType",
")",
"reflect",
".",
"Type",
"{",
"name",
":=",
"strings",
".",
"ToUpper",
"(",
"st",
".",
"Name",
")",
"\n",
"switch",
"name",
"{",
"case",
"Bit",
",",
"TinyInt",
",",
"SmallInt",
",",
"MediumInt",
",",
"Int",
",",
"Integer",
",",
"Serial",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"1",
")",
"\n",
"case",
"BigInt",
",",
"BigSerial",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"int64",
"(",
"1",
")",
")",
"\n",
"case",
"Float",
",",
"Real",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"float32",
"(",
"1",
")",
")",
"\n",
"case",
"Double",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"float64",
"(",
"1",
")",
")",
"\n",
"case",
"Char",
",",
"NChar",
",",
"Varchar",
",",
"NVarchar",
",",
"TinyText",
",",
"Text",
",",
"NText",
",",
"MediumText",
",",
"LongText",
",",
"Enum",
",",
"Set",
",",
"Uuid",
",",
"Clob",
",",
"SysName",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
"\n",
"case",
"TinyBlob",
",",
"Blob",
",",
"LongBlob",
",",
"Bytea",
",",
"Binary",
",",
"MediumBlob",
",",
"VarBinary",
",",
"UniqueIdentifier",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"[",
"]",
"byte",
"{",
"}",
")",
"\n",
"case",
"Bool",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"true",
")",
"\n",
"case",
"DateTime",
",",
"Date",
",",
"Time",
",",
"TimeStamp",
",",
"TimeStampz",
",",
"SmallDateTime",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"c_TIME_DEFAULT",
")",
"\n",
"case",
"Decimal",
",",
"Numeric",
",",
"Money",
",",
"SmallMoney",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
"\n",
"default",
":",
"return",
"reflect",
".",
"TypeOf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// default sql type change to go types
|
[
"default",
"sql",
"type",
"change",
"to",
"go",
"types"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/type.go#L299-L323
|
17,458 |
go-xorm/core
|
column.go
|
ValueOf
|
func (col *Column) ValueOf(bean interface{}) (*reflect.Value, error) {
dataStruct := reflect.Indirect(reflect.ValueOf(bean))
return col.ValueOfV(&dataStruct)
}
|
go
|
func (col *Column) ValueOf(bean interface{}) (*reflect.Value, error) {
dataStruct := reflect.Indirect(reflect.ValueOf(bean))
return col.ValueOfV(&dataStruct)
}
|
[
"func",
"(",
"col",
"*",
"Column",
")",
"ValueOf",
"(",
"bean",
"interface",
"{",
"}",
")",
"(",
"*",
"reflect",
".",
"Value",
",",
"error",
")",
"{",
"dataStruct",
":=",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"bean",
")",
")",
"\n",
"return",
"col",
".",
"ValueOfV",
"(",
"&",
"dataStruct",
")",
"\n",
"}"
] |
// ValueOf returns column's filed of struct's value
|
[
"ValueOf",
"returns",
"column",
"s",
"filed",
"of",
"struct",
"s",
"value"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/column.go#L124-L127
|
17,459 |
go-xorm/core
|
column.go
|
ValueOfV
|
func (col *Column) ValueOfV(dataStruct *reflect.Value) (*reflect.Value, error) {
var fieldValue reflect.Value
fieldPath := strings.Split(col.FieldName, ".")
if dataStruct.Type().Kind() == reflect.Map {
keyValue := reflect.ValueOf(fieldPath[len(fieldPath)-1])
fieldValue = dataStruct.MapIndex(keyValue)
return &fieldValue, nil
} else if dataStruct.Type().Kind() == reflect.Interface {
structValue := reflect.ValueOf(dataStruct.Interface())
dataStruct = &structValue
}
level := len(fieldPath)
fieldValue = dataStruct.FieldByName(fieldPath[0])
for i := 0; i < level-1; i++ {
if !fieldValue.IsValid() {
break
}
if fieldValue.Kind() == reflect.Struct {
fieldValue = fieldValue.FieldByName(fieldPath[i+1])
} else if fieldValue.Kind() == reflect.Ptr {
if fieldValue.IsNil() {
fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
}
fieldValue = fieldValue.Elem().FieldByName(fieldPath[i+1])
} else {
return nil, fmt.Errorf("field %v is not valid", col.FieldName)
}
}
if !fieldValue.IsValid() {
return nil, fmt.Errorf("field %v is not valid", col.FieldName)
}
return &fieldValue, nil
}
|
go
|
func (col *Column) ValueOfV(dataStruct *reflect.Value) (*reflect.Value, error) {
var fieldValue reflect.Value
fieldPath := strings.Split(col.FieldName, ".")
if dataStruct.Type().Kind() == reflect.Map {
keyValue := reflect.ValueOf(fieldPath[len(fieldPath)-1])
fieldValue = dataStruct.MapIndex(keyValue)
return &fieldValue, nil
} else if dataStruct.Type().Kind() == reflect.Interface {
structValue := reflect.ValueOf(dataStruct.Interface())
dataStruct = &structValue
}
level := len(fieldPath)
fieldValue = dataStruct.FieldByName(fieldPath[0])
for i := 0; i < level-1; i++ {
if !fieldValue.IsValid() {
break
}
if fieldValue.Kind() == reflect.Struct {
fieldValue = fieldValue.FieldByName(fieldPath[i+1])
} else if fieldValue.Kind() == reflect.Ptr {
if fieldValue.IsNil() {
fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
}
fieldValue = fieldValue.Elem().FieldByName(fieldPath[i+1])
} else {
return nil, fmt.Errorf("field %v is not valid", col.FieldName)
}
}
if !fieldValue.IsValid() {
return nil, fmt.Errorf("field %v is not valid", col.FieldName)
}
return &fieldValue, nil
}
|
[
"func",
"(",
"col",
"*",
"Column",
")",
"ValueOfV",
"(",
"dataStruct",
"*",
"reflect",
".",
"Value",
")",
"(",
"*",
"reflect",
".",
"Value",
",",
"error",
")",
"{",
"var",
"fieldValue",
"reflect",
".",
"Value",
"\n",
"fieldPath",
":=",
"strings",
".",
"Split",
"(",
"col",
".",
"FieldName",
",",
"\"",
"\"",
")",
"\n\n",
"if",
"dataStruct",
".",
"Type",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Map",
"{",
"keyValue",
":=",
"reflect",
".",
"ValueOf",
"(",
"fieldPath",
"[",
"len",
"(",
"fieldPath",
")",
"-",
"1",
"]",
")",
"\n",
"fieldValue",
"=",
"dataStruct",
".",
"MapIndex",
"(",
"keyValue",
")",
"\n",
"return",
"&",
"fieldValue",
",",
"nil",
"\n",
"}",
"else",
"if",
"dataStruct",
".",
"Type",
"(",
")",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Interface",
"{",
"structValue",
":=",
"reflect",
".",
"ValueOf",
"(",
"dataStruct",
".",
"Interface",
"(",
")",
")",
"\n",
"dataStruct",
"=",
"&",
"structValue",
"\n",
"}",
"\n\n",
"level",
":=",
"len",
"(",
"fieldPath",
")",
"\n",
"fieldValue",
"=",
"dataStruct",
".",
"FieldByName",
"(",
"fieldPath",
"[",
"0",
"]",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"level",
"-",
"1",
";",
"i",
"++",
"{",
"if",
"!",
"fieldValue",
".",
"IsValid",
"(",
")",
"{",
"break",
"\n",
"}",
"\n",
"if",
"fieldValue",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Struct",
"{",
"fieldValue",
"=",
"fieldValue",
".",
"FieldByName",
"(",
"fieldPath",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"else",
"if",
"fieldValue",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"if",
"fieldValue",
".",
"IsNil",
"(",
")",
"{",
"fieldValue",
".",
"Set",
"(",
"reflect",
".",
"New",
"(",
"fieldValue",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"fieldValue",
"=",
"fieldValue",
".",
"Elem",
"(",
")",
".",
"FieldByName",
"(",
"fieldPath",
"[",
"i",
"+",
"1",
"]",
")",
"\n",
"}",
"else",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"col",
".",
"FieldName",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"fieldValue",
".",
"IsValid",
"(",
")",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"col",
".",
"FieldName",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"fieldValue",
",",
"nil",
"\n",
"}"
] |
// ValueOfV returns column's filed of struct's value accept reflevt value
|
[
"ValueOfV",
"returns",
"column",
"s",
"filed",
"of",
"struct",
"s",
"value",
"accept",
"reflevt",
"value"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/column.go#L130-L166
|
17,460 |
go-xorm/core
|
table.go
|
PKColumns
|
func (table *Table) PKColumns() []*Column {
columns := make([]*Column, len(table.PrimaryKeys))
for i, name := range table.PrimaryKeys {
columns[i] = table.GetColumn(name)
}
return columns
}
|
go
|
func (table *Table) PKColumns() []*Column {
columns := make([]*Column, len(table.PrimaryKeys))
for i, name := range table.PrimaryKeys {
columns[i] = table.GetColumn(name)
}
return columns
}
|
[
"func",
"(",
"table",
"*",
"Table",
")",
"PKColumns",
"(",
")",
"[",
"]",
"*",
"Column",
"{",
"columns",
":=",
"make",
"(",
"[",
"]",
"*",
"Column",
",",
"len",
"(",
"table",
".",
"PrimaryKeys",
")",
")",
"\n",
"for",
"i",
",",
"name",
":=",
"range",
"table",
".",
"PrimaryKeys",
"{",
"columns",
"[",
"i",
"]",
"=",
"table",
".",
"GetColumn",
"(",
"name",
")",
"\n",
"}",
"\n",
"return",
"columns",
"\n",
"}"
] |
// if has primary key, return column
|
[
"if",
"has",
"primary",
"key",
"return",
"column"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/table.go#L91-L97
|
17,461 |
go-xorm/core
|
table.go
|
AddColumn
|
func (table *Table) AddColumn(col *Column) {
table.columnsSeq = append(table.columnsSeq, col.Name)
table.columns = append(table.columns, col)
colName := strings.ToLower(col.Name)
if c, ok := table.columnsMap[colName]; ok {
table.columnsMap[colName] = append(c, col)
} else {
table.columnsMap[colName] = []*Column{col}
}
if col.IsPrimaryKey {
table.PrimaryKeys = append(table.PrimaryKeys, col.Name)
}
if col.IsAutoIncrement {
table.AutoIncrement = col.Name
}
if col.IsCreated {
table.Created[col.Name] = true
}
if col.IsUpdated {
table.Updated = col.Name
}
if col.IsDeleted {
table.Deleted = col.Name
}
if col.IsVersion {
table.Version = col.Name
}
}
|
go
|
func (table *Table) AddColumn(col *Column) {
table.columnsSeq = append(table.columnsSeq, col.Name)
table.columns = append(table.columns, col)
colName := strings.ToLower(col.Name)
if c, ok := table.columnsMap[colName]; ok {
table.columnsMap[colName] = append(c, col)
} else {
table.columnsMap[colName] = []*Column{col}
}
if col.IsPrimaryKey {
table.PrimaryKeys = append(table.PrimaryKeys, col.Name)
}
if col.IsAutoIncrement {
table.AutoIncrement = col.Name
}
if col.IsCreated {
table.Created[col.Name] = true
}
if col.IsUpdated {
table.Updated = col.Name
}
if col.IsDeleted {
table.Deleted = col.Name
}
if col.IsVersion {
table.Version = col.Name
}
}
|
[
"func",
"(",
"table",
"*",
"Table",
")",
"AddColumn",
"(",
"col",
"*",
"Column",
")",
"{",
"table",
".",
"columnsSeq",
"=",
"append",
"(",
"table",
".",
"columnsSeq",
",",
"col",
".",
"Name",
")",
"\n",
"table",
".",
"columns",
"=",
"append",
"(",
"table",
".",
"columns",
",",
"col",
")",
"\n",
"colName",
":=",
"strings",
".",
"ToLower",
"(",
"col",
".",
"Name",
")",
"\n",
"if",
"c",
",",
"ok",
":=",
"table",
".",
"columnsMap",
"[",
"colName",
"]",
";",
"ok",
"{",
"table",
".",
"columnsMap",
"[",
"colName",
"]",
"=",
"append",
"(",
"c",
",",
"col",
")",
"\n",
"}",
"else",
"{",
"table",
".",
"columnsMap",
"[",
"colName",
"]",
"=",
"[",
"]",
"*",
"Column",
"{",
"col",
"}",
"\n",
"}",
"\n\n",
"if",
"col",
".",
"IsPrimaryKey",
"{",
"table",
".",
"PrimaryKeys",
"=",
"append",
"(",
"table",
".",
"PrimaryKeys",
",",
"col",
".",
"Name",
")",
"\n",
"}",
"\n",
"if",
"col",
".",
"IsAutoIncrement",
"{",
"table",
".",
"AutoIncrement",
"=",
"col",
".",
"Name",
"\n",
"}",
"\n",
"if",
"col",
".",
"IsCreated",
"{",
"table",
".",
"Created",
"[",
"col",
".",
"Name",
"]",
"=",
"true",
"\n",
"}",
"\n",
"if",
"col",
".",
"IsUpdated",
"{",
"table",
".",
"Updated",
"=",
"col",
".",
"Name",
"\n",
"}",
"\n",
"if",
"col",
".",
"IsDeleted",
"{",
"table",
".",
"Deleted",
"=",
"col",
".",
"Name",
"\n",
"}",
"\n",
"if",
"col",
".",
"IsVersion",
"{",
"table",
".",
"Version",
"=",
"col",
".",
"Name",
"\n",
"}",
"\n",
"}"
] |
// add a column to table
|
[
"add",
"a",
"column",
"to",
"table"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/table.go#L121-L149
|
17,462 |
go-xorm/core
|
table.go
|
AddIndex
|
func (table *Table) AddIndex(index *Index) {
table.Indexes[index.Name] = index
}
|
go
|
func (table *Table) AddIndex(index *Index) {
table.Indexes[index.Name] = index
}
|
[
"func",
"(",
"table",
"*",
"Table",
")",
"AddIndex",
"(",
"index",
"*",
"Index",
")",
"{",
"table",
".",
"Indexes",
"[",
"index",
".",
"Name",
"]",
"=",
"index",
"\n",
"}"
] |
// add an index or an unique to table
|
[
"add",
"an",
"index",
"or",
"an",
"unique",
"to",
"table"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/table.go#L152-L154
|
17,463 |
go-xorm/core
|
db.go
|
Open
|
func Open(driverName, dataSourceName string) (*DB, error) {
db, err := sql.Open(driverName, dataSourceName)
if err != nil {
return nil, err
}
return &DB{
DB: db,
Mapper: NewCacheMapper(&SnakeMapper{}),
reflectCache: make(map[reflect.Type]*cacheStruct),
}, nil
}
|
go
|
func Open(driverName, dataSourceName string) (*DB, error) {
db, err := sql.Open(driverName, dataSourceName)
if err != nil {
return nil, err
}
return &DB{
DB: db,
Mapper: NewCacheMapper(&SnakeMapper{}),
reflectCache: make(map[reflect.Type]*cacheStruct),
}, nil
}
|
[
"func",
"Open",
"(",
"driverName",
",",
"dataSourceName",
"string",
")",
"(",
"*",
"DB",
",",
"error",
")",
"{",
"db",
",",
"err",
":=",
"sql",
".",
"Open",
"(",
"driverName",
",",
"dataSourceName",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"DB",
"{",
"DB",
":",
"db",
",",
"Mapper",
":",
"NewCacheMapper",
"(",
"&",
"SnakeMapper",
"{",
"}",
")",
",",
"reflectCache",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"*",
"cacheStruct",
")",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// Open opens a database
|
[
"Open",
"opens",
"a",
"database"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/db.go#L84-L94
|
17,464 |
go-xorm/core
|
db.go
|
FromDB
|
func FromDB(db *sql.DB) *DB {
return &DB{
DB: db,
Mapper: NewCacheMapper(&SnakeMapper{}),
reflectCache: make(map[reflect.Type]*cacheStruct),
}
}
|
go
|
func FromDB(db *sql.DB) *DB {
return &DB{
DB: db,
Mapper: NewCacheMapper(&SnakeMapper{}),
reflectCache: make(map[reflect.Type]*cacheStruct),
}
}
|
[
"func",
"FromDB",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"*",
"DB",
"{",
"return",
"&",
"DB",
"{",
"DB",
":",
"db",
",",
"Mapper",
":",
"NewCacheMapper",
"(",
"&",
"SnakeMapper",
"{",
"}",
")",
",",
"reflectCache",
":",
"make",
"(",
"map",
"[",
"reflect",
".",
"Type",
"]",
"*",
"cacheStruct",
")",
",",
"}",
"\n",
"}"
] |
// FromDB creates a DB from a sql.DB
|
[
"FromDB",
"creates",
"a",
"DB",
"from",
"a",
"sql",
".",
"DB"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/db.go#L97-L103
|
17,465 |
go-xorm/core
|
db.go
|
QueryContext
|
func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
rows, err := db.DB.QueryContext(ctx, query, args...)
if err != nil {
if rows != nil {
rows.Close()
}
return nil, err
}
return &Rows{rows, db}, nil
}
|
go
|
func (db *DB) QueryContext(ctx context.Context, query string, args ...interface{}) (*Rows, error) {
rows, err := db.DB.QueryContext(ctx, query, args...)
if err != nil {
if rows != nil {
rows.Close()
}
return nil, err
}
return &Rows{rows, db}, nil
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"QueryContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"query",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Rows",
",",
"error",
")",
"{",
"rows",
",",
"err",
":=",
"db",
".",
"DB",
".",
"QueryContext",
"(",
"ctx",
",",
"query",
",",
"args",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"rows",
"!=",
"nil",
"{",
"rows",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Rows",
"{",
"rows",
",",
"db",
"}",
",",
"nil",
"\n",
"}"
] |
// QueryContext overwrites sql.DB.QueryContext
|
[
"QueryContext",
"overwrites",
"sql",
".",
"DB",
".",
"QueryContext"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/db.go#L119-L128
|
17,466 |
go-xorm/core
|
db.go
|
Query
|
func (db *DB) Query(query string, args ...interface{}) (*Rows, error) {
return db.QueryContext(context.Background(), query, args...)
}
|
go
|
func (db *DB) Query(query string, args ...interface{}) (*Rows, error) {
return db.QueryContext(context.Background(), query, args...)
}
|
[
"func",
"(",
"db",
"*",
"DB",
")",
"Query",
"(",
"query",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"(",
"*",
"Rows",
",",
"error",
")",
"{",
"return",
"db",
".",
"QueryContext",
"(",
"context",
".",
"Background",
"(",
")",
",",
"query",
",",
"args",
"...",
")",
"\n",
"}"
] |
// Query overwrites sql.DB.Query
|
[
"Query",
"overwrites",
"sql",
".",
"DB",
".",
"Query"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/db.go#L131-L133
|
17,467 |
go-xorm/core
|
rows.go
|
ScanStructByIndex
|
func (rs *Rows) ScanStructByIndex(dest ...interface{}) error {
if len(dest) == 0 {
return errors.New("at least one struct")
}
vvvs := make([]reflect.Value, len(dest))
for i, s := range dest {
vv := reflect.ValueOf(s)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return errors.New("dest should be a struct's pointer")
}
vvvs[i] = vv.Elem()
}
cols, err := rs.Columns()
if err != nil {
return err
}
newDest := make([]interface{}, len(cols))
var i = 0
for _, vvv := range vvvs {
for j := 0; j < vvv.NumField(); j++ {
newDest[i] = vvv.Field(j).Addr().Interface()
i = i + 1
}
}
return rs.Rows.Scan(newDest...)
}
|
go
|
func (rs *Rows) ScanStructByIndex(dest ...interface{}) error {
if len(dest) == 0 {
return errors.New("at least one struct")
}
vvvs := make([]reflect.Value, len(dest))
for i, s := range dest {
vv := reflect.ValueOf(s)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Struct {
return errors.New("dest should be a struct's pointer")
}
vvvs[i] = vv.Elem()
}
cols, err := rs.Columns()
if err != nil {
return err
}
newDest := make([]interface{}, len(cols))
var i = 0
for _, vvv := range vvvs {
for j := 0; j < vvv.NumField(); j++ {
newDest[i] = vvv.Field(j).Addr().Interface()
i = i + 1
}
}
return rs.Rows.Scan(newDest...)
}
|
[
"func",
"(",
"rs",
"*",
"Rows",
")",
"ScanStructByIndex",
"(",
"dest",
"...",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"len",
"(",
"dest",
")",
"==",
"0",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"vvvs",
":=",
"make",
"(",
"[",
"]",
"reflect",
".",
"Value",
",",
"len",
"(",
"dest",
")",
")",
"\n",
"for",
"i",
",",
"s",
":=",
"range",
"dest",
"{",
"vv",
":=",
"reflect",
".",
"ValueOf",
"(",
"s",
")",
"\n",
"if",
"vv",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"||",
"vv",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"vvvs",
"[",
"i",
"]",
"=",
"vv",
".",
"Elem",
"(",
")",
"\n",
"}",
"\n\n",
"cols",
",",
"err",
":=",
"rs",
".",
"Columns",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"newDest",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"cols",
")",
")",
"\n\n",
"var",
"i",
"=",
"0",
"\n",
"for",
"_",
",",
"vvv",
":=",
"range",
"vvvs",
"{",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"vvv",
".",
"NumField",
"(",
")",
";",
"j",
"++",
"{",
"newDest",
"[",
"i",
"]",
"=",
"vvv",
".",
"Field",
"(",
"j",
")",
".",
"Addr",
"(",
")",
".",
"Interface",
"(",
")",
"\n",
"i",
"=",
"i",
"+",
"1",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"rs",
".",
"Rows",
".",
"Scan",
"(",
"newDest",
"...",
")",
"\n",
"}"
] |
// scan data to a struct's pointer according field index
|
[
"scan",
"data",
"to",
"a",
"struct",
"s",
"pointer",
"according",
"field",
"index"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/rows.go#L38-L68
|
17,468 |
go-xorm/core
|
rows.go
|
ScanSlice
|
func (rs *Rows) ScanSlice(dest interface{}) error {
vv := reflect.ValueOf(dest)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Slice {
return errors.New("dest should be a slice's pointer")
}
vvv := vv.Elem()
cols, err := rs.Columns()
if err != nil {
return err
}
newDest := make([]interface{}, len(cols))
for j := 0; j < len(cols); j++ {
if j >= vvv.Len() {
newDest[j] = reflect.New(vvv.Type().Elem()).Interface()
} else {
newDest[j] = vvv.Index(j).Addr().Interface()
}
}
err = rs.Rows.Scan(newDest...)
if err != nil {
return err
}
srcLen := vvv.Len()
for i := srcLen; i < len(cols); i++ {
vvv = reflect.Append(vvv, reflect.ValueOf(newDest[i]).Elem())
}
return nil
}
|
go
|
func (rs *Rows) ScanSlice(dest interface{}) error {
vv := reflect.ValueOf(dest)
if vv.Kind() != reflect.Ptr || vv.Elem().Kind() != reflect.Slice {
return errors.New("dest should be a slice's pointer")
}
vvv := vv.Elem()
cols, err := rs.Columns()
if err != nil {
return err
}
newDest := make([]interface{}, len(cols))
for j := 0; j < len(cols); j++ {
if j >= vvv.Len() {
newDest[j] = reflect.New(vvv.Type().Elem()).Interface()
} else {
newDest[j] = vvv.Index(j).Addr().Interface()
}
}
err = rs.Rows.Scan(newDest...)
if err != nil {
return err
}
srcLen := vvv.Len()
for i := srcLen; i < len(cols); i++ {
vvv = reflect.Append(vvv, reflect.ValueOf(newDest[i]).Elem())
}
return nil
}
|
[
"func",
"(",
"rs",
"*",
"Rows",
")",
"ScanSlice",
"(",
"dest",
"interface",
"{",
"}",
")",
"error",
"{",
"vv",
":=",
"reflect",
".",
"ValueOf",
"(",
"dest",
")",
"\n",
"if",
"vv",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"||",
"vv",
".",
"Elem",
"(",
")",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Slice",
"{",
"return",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"vvv",
":=",
"vv",
".",
"Elem",
"(",
")",
"\n",
"cols",
",",
"err",
":=",
"rs",
".",
"Columns",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"newDest",
":=",
"make",
"(",
"[",
"]",
"interface",
"{",
"}",
",",
"len",
"(",
"cols",
")",
")",
"\n\n",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"len",
"(",
"cols",
")",
";",
"j",
"++",
"{",
"if",
"j",
">=",
"vvv",
".",
"Len",
"(",
")",
"{",
"newDest",
"[",
"j",
"]",
"=",
"reflect",
".",
"New",
"(",
"vvv",
".",
"Type",
"(",
")",
".",
"Elem",
"(",
")",
")",
".",
"Interface",
"(",
")",
"\n",
"}",
"else",
"{",
"newDest",
"[",
"j",
"]",
"=",
"vvv",
".",
"Index",
"(",
"j",
")",
".",
"Addr",
"(",
")",
".",
"Interface",
"(",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"err",
"=",
"rs",
".",
"Rows",
".",
"Scan",
"(",
"newDest",
"...",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"srcLen",
":=",
"vvv",
".",
"Len",
"(",
")",
"\n",
"for",
"i",
":=",
"srcLen",
";",
"i",
"<",
"len",
"(",
"cols",
")",
";",
"i",
"++",
"{",
"vvv",
"=",
"reflect",
".",
"Append",
"(",
"vvv",
",",
"reflect",
".",
"ValueOf",
"(",
"newDest",
"[",
"i",
"]",
")",
".",
"Elem",
"(",
")",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// scan data to a slice's pointer, slice's length should equal to columns' number
|
[
"scan",
"data",
"to",
"a",
"slice",
"s",
"pointer",
"slice",
"s",
"length",
"should",
"equal",
"to",
"columns",
"number"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/rows.go#L124-L156
|
17,469 |
go-xorm/core
|
dialect.go
|
RegisterDialect
|
func RegisterDialect(dbName DbType, dialectFunc func() Dialect) {
if dialectFunc == nil {
panic("core: Register dialect is nil")
}
dialects[strings.ToLower(string(dbName))] = dialectFunc // !nashtsai! allow override dialect
}
|
go
|
func RegisterDialect(dbName DbType, dialectFunc func() Dialect) {
if dialectFunc == nil {
panic("core: Register dialect is nil")
}
dialects[strings.ToLower(string(dbName))] = dialectFunc // !nashtsai! allow override dialect
}
|
[
"func",
"RegisterDialect",
"(",
"dbName",
"DbType",
",",
"dialectFunc",
"func",
"(",
")",
"Dialect",
")",
"{",
"if",
"dialectFunc",
"==",
"nil",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"dialects",
"[",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"dbName",
")",
")",
"]",
"=",
"dialectFunc",
"// !nashtsai! allow override dialect",
"\n",
"}"
] |
// RegisterDialect register database dialect
|
[
"RegisterDialect",
"register",
"database",
"dialect"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/dialect.go#L306-L311
|
17,470 |
go-xorm/core
|
dialect.go
|
QueryDialect
|
func QueryDialect(dbName DbType) Dialect {
if d, ok := dialects[strings.ToLower(string(dbName))]; ok {
return d()
}
return nil
}
|
go
|
func QueryDialect(dbName DbType) Dialect {
if d, ok := dialects[strings.ToLower(string(dbName))]; ok {
return d()
}
return nil
}
|
[
"func",
"QueryDialect",
"(",
"dbName",
"DbType",
")",
"Dialect",
"{",
"if",
"d",
",",
"ok",
":=",
"dialects",
"[",
"strings",
".",
"ToLower",
"(",
"string",
"(",
"dbName",
")",
")",
"]",
";",
"ok",
"{",
"return",
"d",
"(",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
// QueryDialect query if registed database dialect
|
[
"QueryDialect",
"query",
"if",
"registed",
"database",
"dialect"
] |
ccc80c1adf1f6172bbc548877f50a1163041a40a
|
https://github.com/go-xorm/core/blob/ccc80c1adf1f6172bbc548877f50a1163041a40a/dialect.go#L314-L319
|
17,471 |
thriftrw/thriftrw-go
|
ast/walk.go
|
Walk
|
func Walk(v Visitor, n Node) {
visitor{Visitor: v}.visit(nil, n)
}
|
go
|
func Walk(v Visitor, n Node) {
visitor{Visitor: v}.visit(nil, n)
}
|
[
"func",
"Walk",
"(",
"v",
"Visitor",
",",
"n",
"Node",
")",
"{",
"visitor",
"{",
"Visitor",
":",
"v",
"}",
".",
"visit",
"(",
"nil",
",",
"n",
")",
"\n",
"}"
] |
// Walk walks the AST depth-first with the given visitor, starting at the
// given node. The visitor's Visit function should return a non-nil visitor if
// it wants to visit the children of the node it was called with.
|
[
"Walk",
"walks",
"the",
"AST",
"depth",
"-",
"first",
"with",
"the",
"given",
"visitor",
"starting",
"at",
"the",
"given",
"node",
".",
"The",
"visitor",
"s",
"Visit",
"function",
"should",
"return",
"a",
"non",
"-",
"nil",
"visitor",
"if",
"it",
"wants",
"to",
"visit",
"the",
"children",
"of",
"the",
"node",
"it",
"was",
"called",
"with",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/ast/walk.go#L26-L28
|
17,472 |
thriftrw/thriftrw-go
|
wire/value_equals.go
|
ValuesAreEqual
|
func ValuesAreEqual(left, right Value) bool {
if left.typ != right.typ {
return false
}
switch left.typ {
case TBool:
return left.GetBool() == right.GetBool()
case TI8:
return left.GetI8() == right.GetI8()
case TDouble:
return left.GetDouble() == right.GetDouble()
case TI16:
return left.GetI16() == right.GetI16()
case TI32:
return left.GetI32() == right.GetI32()
case TI64:
return left.GetI64() == right.GetI64()
case TBinary:
return bytes.Equal(left.tbinary, right.tbinary)
case TStruct:
return StructsAreEqual(left.tstruct, right.tstruct)
case TMap:
return MapsAreEqual(left.tcoll.(MapItemList), right.tcoll.(MapItemList))
case TSet:
return SetsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
case TList:
return ListsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
default:
return false
}
}
|
go
|
func ValuesAreEqual(left, right Value) bool {
if left.typ != right.typ {
return false
}
switch left.typ {
case TBool:
return left.GetBool() == right.GetBool()
case TI8:
return left.GetI8() == right.GetI8()
case TDouble:
return left.GetDouble() == right.GetDouble()
case TI16:
return left.GetI16() == right.GetI16()
case TI32:
return left.GetI32() == right.GetI32()
case TI64:
return left.GetI64() == right.GetI64()
case TBinary:
return bytes.Equal(left.tbinary, right.tbinary)
case TStruct:
return StructsAreEqual(left.tstruct, right.tstruct)
case TMap:
return MapsAreEqual(left.tcoll.(MapItemList), right.tcoll.(MapItemList))
case TSet:
return SetsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
case TList:
return ListsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
default:
return false
}
}
|
[
"func",
"ValuesAreEqual",
"(",
"left",
",",
"right",
"Value",
")",
"bool",
"{",
"if",
"left",
".",
"typ",
"!=",
"right",
".",
"typ",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"switch",
"left",
".",
"typ",
"{",
"case",
"TBool",
":",
"return",
"left",
".",
"GetBool",
"(",
")",
"==",
"right",
".",
"GetBool",
"(",
")",
"\n",
"case",
"TI8",
":",
"return",
"left",
".",
"GetI8",
"(",
")",
"==",
"right",
".",
"GetI8",
"(",
")",
"\n",
"case",
"TDouble",
":",
"return",
"left",
".",
"GetDouble",
"(",
")",
"==",
"right",
".",
"GetDouble",
"(",
")",
"\n",
"case",
"TI16",
":",
"return",
"left",
".",
"GetI16",
"(",
")",
"==",
"right",
".",
"GetI16",
"(",
")",
"\n",
"case",
"TI32",
":",
"return",
"left",
".",
"GetI32",
"(",
")",
"==",
"right",
".",
"GetI32",
"(",
")",
"\n",
"case",
"TI64",
":",
"return",
"left",
".",
"GetI64",
"(",
")",
"==",
"right",
".",
"GetI64",
"(",
")",
"\n",
"case",
"TBinary",
":",
"return",
"bytes",
".",
"Equal",
"(",
"left",
".",
"tbinary",
",",
"right",
".",
"tbinary",
")",
"\n",
"case",
"TStruct",
":",
"return",
"StructsAreEqual",
"(",
"left",
".",
"tstruct",
",",
"right",
".",
"tstruct",
")",
"\n",
"case",
"TMap",
":",
"return",
"MapsAreEqual",
"(",
"left",
".",
"tcoll",
".",
"(",
"MapItemList",
")",
",",
"right",
".",
"tcoll",
".",
"(",
"MapItemList",
")",
")",
"\n",
"case",
"TSet",
":",
"return",
"SetsAreEqual",
"(",
"left",
".",
"tcoll",
".",
"(",
"ValueList",
")",
",",
"right",
".",
"tcoll",
".",
"(",
"ValueList",
")",
")",
"\n",
"case",
"TList",
":",
"return",
"ListsAreEqual",
"(",
"left",
".",
"tcoll",
".",
"(",
"ValueList",
")",
",",
"right",
".",
"tcoll",
".",
"(",
"ValueList",
")",
")",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] |
// ValuesAreEqual checks if two values are equal.
|
[
"ValuesAreEqual",
"checks",
"if",
"two",
"values",
"are",
"equal",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/wire/value_equals.go#L34-L65
|
17,473 |
thriftrw/thriftrw-go
|
wire/value_equals.go
|
StructsAreEqual
|
func StructsAreEqual(left, right Struct) bool {
if len(left.Fields) != len(right.Fields) {
return false
}
// Fields are unordered so we need to build a map to actually compare
// them.
leftFields := left.fieldMap()
rightFields := right.fieldMap()
for i, lvalue := range leftFields {
if rvalue, ok := rightFields[i]; !ok {
return false
} else if !ValuesAreEqual(lvalue, rvalue) {
return false
}
}
return true
}
|
go
|
func StructsAreEqual(left, right Struct) bool {
if len(left.Fields) != len(right.Fields) {
return false
}
// Fields are unordered so we need to build a map to actually compare
// them.
leftFields := left.fieldMap()
rightFields := right.fieldMap()
for i, lvalue := range leftFields {
if rvalue, ok := rightFields[i]; !ok {
return false
} else if !ValuesAreEqual(lvalue, rvalue) {
return false
}
}
return true
}
|
[
"func",
"StructsAreEqual",
"(",
"left",
",",
"right",
"Struct",
")",
"bool",
"{",
"if",
"len",
"(",
"left",
".",
"Fields",
")",
"!=",
"len",
"(",
"right",
".",
"Fields",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"// Fields are unordered so we need to build a map to actually compare",
"// them.",
"leftFields",
":=",
"left",
".",
"fieldMap",
"(",
")",
"\n",
"rightFields",
":=",
"right",
".",
"fieldMap",
"(",
")",
"\n\n",
"for",
"i",
",",
"lvalue",
":=",
"range",
"leftFields",
"{",
"if",
"rvalue",
",",
"ok",
":=",
"rightFields",
"[",
"i",
"]",
";",
"!",
"ok",
"{",
"return",
"false",
"\n",
"}",
"else",
"if",
"!",
"ValuesAreEqual",
"(",
"lvalue",
",",
"rvalue",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// StructsAreEqual checks if two structs are equal.
|
[
"StructsAreEqual",
"checks",
"if",
"two",
"structs",
"are",
"equal",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/wire/value_equals.go#L68-L88
|
17,474 |
thriftrw/thriftrw-go
|
wire/value_equals.go
|
SetsAreEqual
|
func SetsAreEqual(left, right ValueList) bool {
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
if isHashable(left.ValueType()) {
return setsArEqualHashable(left.Size(), left, right)
}
return setsAreEqualUnhashable(left.Size(), left, right)
}
|
go
|
func SetsAreEqual(left, right ValueList) bool {
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
if isHashable(left.ValueType()) {
return setsArEqualHashable(left.Size(), left, right)
}
return setsAreEqualUnhashable(left.Size(), left, right)
}
|
[
"func",
"SetsAreEqual",
"(",
"left",
",",
"right",
"ValueList",
")",
"bool",
"{",
"if",
"left",
".",
"ValueType",
"(",
")",
"!=",
"right",
".",
"ValueType",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"left",
".",
"Size",
"(",
")",
"!=",
"right",
".",
"Size",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"isHashable",
"(",
"left",
".",
"ValueType",
"(",
")",
")",
"{",
"return",
"setsArEqualHashable",
"(",
"left",
".",
"Size",
"(",
")",
",",
"left",
",",
"right",
")",
"\n",
"}",
"\n",
"return",
"setsAreEqualUnhashable",
"(",
"left",
".",
"Size",
"(",
")",
",",
"left",
",",
"right",
")",
"\n",
"}"
] |
// SetsAreEqual checks if two sets are equal.
|
[
"SetsAreEqual",
"checks",
"if",
"two",
"sets",
"are",
"equal",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/wire/value_equals.go#L91-L103
|
17,475 |
thriftrw/thriftrw-go
|
wire/value_equals.go
|
MapsAreEqual
|
func MapsAreEqual(left, right MapItemList) bool {
if left.KeyType() != right.KeyType() {
return false
}
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
if isHashable(left.KeyType()) {
return mapsAreEqualHashable(left.Size(), left, right)
}
return mapsAreEqualUnhashable(left.Size(), left, right)
}
|
go
|
func MapsAreEqual(left, right MapItemList) bool {
if left.KeyType() != right.KeyType() {
return false
}
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
if isHashable(left.KeyType()) {
return mapsAreEqualHashable(left.Size(), left, right)
}
return mapsAreEqualUnhashable(left.Size(), left, right)
}
|
[
"func",
"MapsAreEqual",
"(",
"left",
",",
"right",
"MapItemList",
")",
"bool",
"{",
"if",
"left",
".",
"KeyType",
"(",
")",
"!=",
"right",
".",
"KeyType",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"left",
".",
"ValueType",
"(",
")",
"!=",
"right",
".",
"ValueType",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"left",
".",
"Size",
"(",
")",
"!=",
"right",
".",
"Size",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"if",
"isHashable",
"(",
"left",
".",
"KeyType",
"(",
")",
")",
"{",
"return",
"mapsAreEqualHashable",
"(",
"left",
".",
"Size",
"(",
")",
",",
"left",
",",
"right",
")",
"\n",
"}",
"\n",
"return",
"mapsAreEqualUnhashable",
"(",
"left",
".",
"Size",
"(",
")",
",",
"left",
",",
"right",
")",
"\n",
"}"
] |
// MapsAreEqual checks if two maps are equal.
|
[
"MapsAreEqual",
"checks",
"if",
"two",
"maps",
"are",
"equal",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/wire/value_equals.go#L145-L160
|
17,476 |
thriftrw/thriftrw-go
|
wire/value_equals.go
|
ListsAreEqual
|
func ListsAreEqual(left, right ValueList) bool {
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
leftItems := ValueListToSlice(left)
rightItems := ValueListToSlice(right)
for i, lv := range leftItems {
rv := rightItems[i]
if !ValuesAreEqual(lv, rv) {
return false
}
}
return true
}
|
go
|
func ListsAreEqual(left, right ValueList) bool {
if left.ValueType() != right.ValueType() {
return false
}
if left.Size() != right.Size() {
return false
}
leftItems := ValueListToSlice(left)
rightItems := ValueListToSlice(right)
for i, lv := range leftItems {
rv := rightItems[i]
if !ValuesAreEqual(lv, rv) {
return false
}
}
return true
}
|
[
"func",
"ListsAreEqual",
"(",
"left",
",",
"right",
"ValueList",
")",
"bool",
"{",
"if",
"left",
".",
"ValueType",
"(",
")",
"!=",
"right",
".",
"ValueType",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"left",
".",
"Size",
"(",
")",
"!=",
"right",
".",
"Size",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"leftItems",
":=",
"ValueListToSlice",
"(",
"left",
")",
"\n",
"rightItems",
":=",
"ValueListToSlice",
"(",
"right",
")",
"\n\n",
"for",
"i",
",",
"lv",
":=",
"range",
"leftItems",
"{",
"rv",
":=",
"rightItems",
"[",
"i",
"]",
"\n",
"if",
"!",
"ValuesAreEqual",
"(",
"lv",
",",
"rv",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// ListsAreEqual checks if two lists are equal.
|
[
"ListsAreEqual",
"checks",
"if",
"two",
"lists",
"are",
"equal",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/wire/value_equals.go#L226-L245
|
17,477 |
thriftrw/thriftrw-go
|
compile/typedef.go
|
compileTypedef
|
func compileTypedef(file string, src *ast.Typedef) (*TypedefSpec, error) {
typ, err := compileTypeReference(src.Type)
if err != nil {
return nil, err
}
annotations, err := compileAnnotations(src.Annotations)
if err != nil {
return nil, compileError{
Target: src.Name,
Line: src.Line,
Reason: err,
}
}
return &TypedefSpec{
Name: src.Name,
File: file,
Target: typ,
Annotations: annotations,
Doc: src.Doc,
}, nil
}
|
go
|
func compileTypedef(file string, src *ast.Typedef) (*TypedefSpec, error) {
typ, err := compileTypeReference(src.Type)
if err != nil {
return nil, err
}
annotations, err := compileAnnotations(src.Annotations)
if err != nil {
return nil, compileError{
Target: src.Name,
Line: src.Line,
Reason: err,
}
}
return &TypedefSpec{
Name: src.Name,
File: file,
Target: typ,
Annotations: annotations,
Doc: src.Doc,
}, nil
}
|
[
"func",
"compileTypedef",
"(",
"file",
"string",
",",
"src",
"*",
"ast",
".",
"Typedef",
")",
"(",
"*",
"TypedefSpec",
",",
"error",
")",
"{",
"typ",
",",
"err",
":=",
"compileTypeReference",
"(",
"src",
".",
"Type",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"annotations",
",",
"err",
":=",
"compileAnnotations",
"(",
"src",
".",
"Annotations",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"compileError",
"{",
"Target",
":",
"src",
".",
"Name",
",",
"Line",
":",
"src",
".",
"Line",
",",
"Reason",
":",
"err",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"TypedefSpec",
"{",
"Name",
":",
"src",
".",
"Name",
",",
"File",
":",
"file",
",",
"Target",
":",
"typ",
",",
"Annotations",
":",
"annotations",
",",
"Doc",
":",
"src",
".",
"Doc",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// compileTypedef compiles the given Typedef AST into a TypedefSpec.
|
[
"compileTypedef",
"compiles",
"the",
"given",
"Typedef",
"AST",
"into",
"a",
"TypedefSpec",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/typedef.go#L42-L64
|
17,478 |
thriftrw/thriftrw-go
|
compile/typedef.go
|
Link
|
func (t *TypedefSpec) Link(scope Scope) (TypeSpec, error) {
if t.linked() {
return t, nil
}
var err error
t.Target, err = t.Target.Link(scope)
if err == nil {
t.root = RootTypeSpec(t.Target)
}
return t, err
}
|
go
|
func (t *TypedefSpec) Link(scope Scope) (TypeSpec, error) {
if t.linked() {
return t, nil
}
var err error
t.Target, err = t.Target.Link(scope)
if err == nil {
t.root = RootTypeSpec(t.Target)
}
return t, err
}
|
[
"func",
"(",
"t",
"*",
"TypedefSpec",
")",
"Link",
"(",
"scope",
"Scope",
")",
"(",
"TypeSpec",
",",
"error",
")",
"{",
"if",
"t",
".",
"linked",
"(",
")",
"{",
"return",
"t",
",",
"nil",
"\n",
"}",
"\n\n",
"var",
"err",
"error",
"\n",
"t",
".",
"Target",
",",
"err",
"=",
"t",
".",
"Target",
".",
"Link",
"(",
"scope",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"t",
".",
"root",
"=",
"RootTypeSpec",
"(",
"t",
".",
"Target",
")",
"\n",
"}",
"\n",
"return",
"t",
",",
"err",
"\n",
"}"
] |
// Link links the Target TypeSpec for this typedef in the given scope.
|
[
"Link",
"links",
"the",
"Target",
"TypeSpec",
"for",
"this",
"typedef",
"in",
"the",
"given",
"scope",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/typedef.go#L72-L83
|
17,479 |
thriftrw/thriftrw-go
|
compile/typedef.go
|
ForEachTypeReference
|
func (t *TypedefSpec) ForEachTypeReference(f func(TypeSpec) error) error {
return f(t.Target)
}
|
go
|
func (t *TypedefSpec) ForEachTypeReference(f func(TypeSpec) error) error {
return f(t.Target)
}
|
[
"func",
"(",
"t",
"*",
"TypedefSpec",
")",
"ForEachTypeReference",
"(",
"f",
"func",
"(",
"TypeSpec",
")",
"error",
")",
"error",
"{",
"return",
"f",
"(",
"t",
".",
"Target",
")",
"\n",
"}"
] |
// ForEachTypeReference for TypedefSpec
|
[
"ForEachTypeReference",
"for",
"TypedefSpec"
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/typedef.go#L96-L98
|
17,480 |
thriftrw/thriftrw-go
|
idl/internal/parser.go
|
Parse
|
func Parse(s []byte) (*ast.Program, error) {
lex := newLexer(s)
e := yyParse(lex)
if e == 0 && !lex.parseFailed {
return lex.program, nil
}
return nil, lex.err
}
|
go
|
func Parse(s []byte) (*ast.Program, error) {
lex := newLexer(s)
e := yyParse(lex)
if e == 0 && !lex.parseFailed {
return lex.program, nil
}
return nil, lex.err
}
|
[
"func",
"Parse",
"(",
"s",
"[",
"]",
"byte",
")",
"(",
"*",
"ast",
".",
"Program",
",",
"error",
")",
"{",
"lex",
":=",
"newLexer",
"(",
"s",
")",
"\n",
"e",
":=",
"yyParse",
"(",
"lex",
")",
"\n",
"if",
"e",
"==",
"0",
"&&",
"!",
"lex",
".",
"parseFailed",
"{",
"return",
"lex",
".",
"program",
",",
"nil",
"\n",
"}",
"\n",
"return",
"nil",
",",
"lex",
".",
"err",
"\n",
"}"
] |
// Parse parses the given Thrift document.
|
[
"Parse",
"parses",
"the",
"given",
"Thrift",
"document",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/idl/internal/parser.go#L30-L37
|
17,481 |
thriftrw/thriftrw-go
|
protocol/binary/envelope.go
|
WriteEnveloped
|
func (bw *Writer) WriteEnveloped(e wire.Envelope) error {
version := uint32(version1) | uint32(e.Type)
if err := bw.writeInt32(int32(version)); err != nil {
return err
}
if err := bw.writeString(e.Name); err != nil {
return err
}
if err := bw.writeInt32(e.SeqID); err != nil {
return err
}
return bw.WriteValue(e.Value)
}
|
go
|
func (bw *Writer) WriteEnveloped(e wire.Envelope) error {
version := uint32(version1) | uint32(e.Type)
if err := bw.writeInt32(int32(version)); err != nil {
return err
}
if err := bw.writeString(e.Name); err != nil {
return err
}
if err := bw.writeInt32(e.SeqID); err != nil {
return err
}
return bw.WriteValue(e.Value)
}
|
[
"func",
"(",
"bw",
"*",
"Writer",
")",
"WriteEnveloped",
"(",
"e",
"wire",
".",
"Envelope",
")",
"error",
"{",
"version",
":=",
"uint32",
"(",
"version1",
")",
"|",
"uint32",
"(",
"e",
".",
"Type",
")",
"\n\n",
"if",
"err",
":=",
"bw",
".",
"writeInt32",
"(",
"int32",
"(",
"version",
")",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"bw",
".",
"writeString",
"(",
"e",
".",
"Name",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"bw",
".",
"writeInt32",
"(",
"e",
".",
"SeqID",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"bw",
".",
"WriteValue",
"(",
"e",
".",
"Value",
")",
"\n",
"}"
] |
// WriteEnveloped writes enveloped value using the strict envelope.
|
[
"WriteEnveloped",
"writes",
"enveloped",
"value",
"using",
"the",
"strict",
"envelope",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/protocol/binary/envelope.go#L35-L51
|
17,482 |
thriftrw/thriftrw-go
|
gen/type.go
|
TypeDefinition
|
func TypeDefinition(g Generator, spec compile.TypeSpec) error {
switch s := spec.(type) {
case *compile.EnumSpec:
return enum(g, s)
case *compile.StructSpec:
return structure(g, s)
case *compile.TypedefSpec:
return typedef(g, s)
default:
panic(fmt.Sprintf("%q is not a defined type", spec.ThriftName()))
}
}
|
go
|
func TypeDefinition(g Generator, spec compile.TypeSpec) error {
switch s := spec.(type) {
case *compile.EnumSpec:
return enum(g, s)
case *compile.StructSpec:
return structure(g, s)
case *compile.TypedefSpec:
return typedef(g, s)
default:
panic(fmt.Sprintf("%q is not a defined type", spec.ThriftName()))
}
}
|
[
"func",
"TypeDefinition",
"(",
"g",
"Generator",
",",
"spec",
"compile",
".",
"TypeSpec",
")",
"error",
"{",
"switch",
"s",
":=",
"spec",
".",
"(",
"type",
")",
"{",
"case",
"*",
"compile",
".",
"EnumSpec",
":",
"return",
"enum",
"(",
"g",
",",
"s",
")",
"\n",
"case",
"*",
"compile",
".",
"StructSpec",
":",
"return",
"structure",
"(",
"g",
",",
"s",
")",
"\n",
"case",
"*",
"compile",
".",
"TypedefSpec",
":",
"return",
"typedef",
"(",
"g",
",",
"s",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"spec",
".",
"ThriftName",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// TypeDefinition generates code for the given TypeSpec.
|
[
"TypeDefinition",
"generates",
"code",
"for",
"the",
"given",
"TypeSpec",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/type.go#L30-L41
|
17,483 |
thriftrw/thriftrw-go
|
gen/type.go
|
isReferenceType
|
func isReferenceType(spec compile.TypeSpec) bool {
spec = compile.RootTypeSpec(spec)
if _, ok := spec.(*compile.BinarySpec); ok {
return true
}
switch spec.(type) {
case *compile.MapSpec, *compile.ListSpec, *compile.SetSpec:
return true
default:
return false
}
}
|
go
|
func isReferenceType(spec compile.TypeSpec) bool {
spec = compile.RootTypeSpec(spec)
if _, ok := spec.(*compile.BinarySpec); ok {
return true
}
switch spec.(type) {
case *compile.MapSpec, *compile.ListSpec, *compile.SetSpec:
return true
default:
return false
}
}
|
[
"func",
"isReferenceType",
"(",
"spec",
"compile",
".",
"TypeSpec",
")",
"bool",
"{",
"spec",
"=",
"compile",
".",
"RootTypeSpec",
"(",
"spec",
")",
"\n",
"if",
"_",
",",
"ok",
":=",
"spec",
".",
"(",
"*",
"compile",
".",
"BinarySpec",
")",
";",
"ok",
"{",
"return",
"true",
"\n",
"}",
"\n\n",
"switch",
"spec",
".",
"(",
"type",
")",
"{",
"case",
"*",
"compile",
".",
"MapSpec",
",",
"*",
"compile",
".",
"ListSpec",
",",
"*",
"compile",
".",
"SetSpec",
":",
"return",
"true",
"\n",
"default",
":",
"return",
"false",
"\n",
"}",
"\n",
"}"
] |
// isReferenceType checks if the given TypeSpec represents a reference type.
//
// Sets, maps, lists, and slices are reference types.
|
[
"isReferenceType",
"checks",
"if",
"the",
"given",
"TypeSpec",
"represents",
"a",
"reference",
"type",
".",
"Sets",
"maps",
"lists",
"and",
"slices",
"are",
"reference",
"types",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/type.go#L80-L92
|
17,484 |
thriftrw/thriftrw-go
|
gen/type.go
|
typeReference
|
func typeReference(g Generator, spec compile.TypeSpec) (string, error) {
name, err := typeName(g, spec)
if err != nil {
return "", err
}
if isStructType(spec) {
// Prepend "*" to the result if the field is not required and the type
// isn't a reference type.
name = "*" + name
}
return name, nil
}
|
go
|
func typeReference(g Generator, spec compile.TypeSpec) (string, error) {
name, err := typeName(g, spec)
if err != nil {
return "", err
}
if isStructType(spec) {
// Prepend "*" to the result if the field is not required and the type
// isn't a reference type.
name = "*" + name
}
return name, nil
}
|
[
"func",
"typeReference",
"(",
"g",
"Generator",
",",
"spec",
"compile",
".",
"TypeSpec",
")",
"(",
"string",
",",
"error",
")",
"{",
"name",
",",
"err",
":=",
"typeName",
"(",
"g",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"isStructType",
"(",
"spec",
")",
"{",
"// Prepend \"*\" to the result if the field is not required and the type",
"// isn't a reference type.",
"name",
"=",
"\"",
"\"",
"+",
"name",
"\n",
"}",
"\n",
"return",
"name",
",",
"nil",
"\n",
"}"
] |
// typeReference returns a string representation of a reference to the given
// type.
|
[
"typeReference",
"returns",
"a",
"string",
"representation",
"of",
"a",
"reference",
"to",
"the",
"given",
"type",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/type.go#L102-L113
|
17,485 |
thriftrw/thriftrw-go
|
gen/type.go
|
typeReferencePtr
|
func typeReferencePtr(g Generator, spec compile.TypeSpec) (string, error) {
ref, err := typeName(g, spec)
if err != nil {
return "", err
}
if !isReferenceType(spec) {
// need * prefix for everything but map, string, and list.
return "*" + ref, nil
}
return ref, nil
}
|
go
|
func typeReferencePtr(g Generator, spec compile.TypeSpec) (string, error) {
ref, err := typeName(g, spec)
if err != nil {
return "", err
}
if !isReferenceType(spec) {
// need * prefix for everything but map, string, and list.
return "*" + ref, nil
}
return ref, nil
}
|
[
"func",
"typeReferencePtr",
"(",
"g",
"Generator",
",",
"spec",
"compile",
".",
"TypeSpec",
")",
"(",
"string",
",",
"error",
")",
"{",
"ref",
",",
"err",
":=",
"typeName",
"(",
"g",
",",
"spec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"isReferenceType",
"(",
"spec",
")",
"{",
"// need * prefix for everything but map, string, and list.",
"return",
"\"",
"\"",
"+",
"ref",
",",
"nil",
"\n",
"}",
"\n",
"return",
"ref",
",",
"nil",
"\n",
"}"
] |
// typeReferencePtr returns a strung representing a reference to a pointer of
// the given type. The pointer prefix is not added for types that are already
// reference types.
|
[
"typeReferencePtr",
"returns",
"a",
"strung",
"representing",
"a",
"reference",
"to",
"a",
"pointer",
"of",
"the",
"given",
"type",
".",
"The",
"pointer",
"prefix",
"is",
"not",
"added",
"for",
"types",
"that",
"are",
"already",
"reference",
"types",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/type.go#L118-L128
|
17,486 |
thriftrw/thriftrw-go
|
gen/type.go
|
typeName
|
func typeName(g Generator, spec compile.TypeSpec) (string, error) {
switch s := spec.(type) {
case *compile.BoolSpec:
return "bool", nil
case *compile.I8Spec:
return "int8", nil
case *compile.I16Spec:
return "int16", nil
case *compile.I32Spec:
return "int32", nil
case *compile.I64Spec:
return "int64", nil
case *compile.DoubleSpec:
return "float64", nil
case *compile.StringSpec:
return "string", nil
case *compile.BinarySpec:
return "[]byte", nil
case *compile.MapSpec:
k, err := typeReference(g, s.KeySpec)
if err != nil {
return "", err
}
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
if !isHashable(s.KeySpec) {
// unhashable type
return fmt.Sprintf("[]struct{Key %s; Value %s}", k, v), nil
}
return fmt.Sprintf("map[%s]%s", k, v), nil
case *compile.ListSpec:
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
return "[]" + v, nil
case *compile.SetSpec:
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
// not annotated to be slice and hashable value type
if setUsesMap(s) {
return fmt.Sprintf("map[%s]struct{}", v), nil
}
return fmt.Sprintf("[]%s", v), nil
case *compile.EnumSpec, *compile.StructSpec, *compile.TypedefSpec:
return g.LookupTypeName(spec)
default:
panic(fmt.Sprintf("Unknown type (%T) %v", spec, spec))
}
}
|
go
|
func typeName(g Generator, spec compile.TypeSpec) (string, error) {
switch s := spec.(type) {
case *compile.BoolSpec:
return "bool", nil
case *compile.I8Spec:
return "int8", nil
case *compile.I16Spec:
return "int16", nil
case *compile.I32Spec:
return "int32", nil
case *compile.I64Spec:
return "int64", nil
case *compile.DoubleSpec:
return "float64", nil
case *compile.StringSpec:
return "string", nil
case *compile.BinarySpec:
return "[]byte", nil
case *compile.MapSpec:
k, err := typeReference(g, s.KeySpec)
if err != nil {
return "", err
}
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
if !isHashable(s.KeySpec) {
// unhashable type
return fmt.Sprintf("[]struct{Key %s; Value %s}", k, v), nil
}
return fmt.Sprintf("map[%s]%s", k, v), nil
case *compile.ListSpec:
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
return "[]" + v, nil
case *compile.SetSpec:
v, err := typeReference(g, s.ValueSpec)
if err != nil {
return "", err
}
// not annotated to be slice and hashable value type
if setUsesMap(s) {
return fmt.Sprintf("map[%s]struct{}", v), nil
}
return fmt.Sprintf("[]%s", v), nil
case *compile.EnumSpec, *compile.StructSpec, *compile.TypedefSpec:
return g.LookupTypeName(spec)
default:
panic(fmt.Sprintf("Unknown type (%T) %v", spec, spec))
}
}
|
[
"func",
"typeName",
"(",
"g",
"Generator",
",",
"spec",
"compile",
".",
"TypeSpec",
")",
"(",
"string",
",",
"error",
")",
"{",
"switch",
"s",
":=",
"spec",
".",
"(",
"type",
")",
"{",
"case",
"*",
"compile",
".",
"BoolSpec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"I8Spec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"I16Spec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"I32Spec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"I64Spec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"DoubleSpec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"StringSpec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"BinarySpec",
":",
"return",
"\"",
"\"",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"MapSpec",
":",
"k",
",",
"err",
":=",
"typeReference",
"(",
"g",
",",
"s",
".",
"KeySpec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"v",
",",
"err",
":=",
"typeReference",
"(",
"g",
",",
"s",
".",
"ValueSpec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"if",
"!",
"isHashable",
"(",
"s",
".",
"KeySpec",
")",
"{",
"// unhashable type",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"k",
",",
"v",
")",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"ListSpec",
":",
"v",
",",
"err",
":=",
"typeReference",
"(",
"g",
",",
"s",
".",
"ValueSpec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"\"",
"\"",
"+",
"v",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"SetSpec",
":",
"v",
",",
"err",
":=",
"typeReference",
"(",
"g",
",",
"s",
".",
"ValueSpec",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"// not annotated to be slice and hashable value type",
"if",
"setUsesMap",
"(",
"s",
")",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
")",
",",
"nil",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"v",
")",
",",
"nil",
"\n",
"case",
"*",
"compile",
".",
"EnumSpec",
",",
"*",
"compile",
".",
"StructSpec",
",",
"*",
"compile",
".",
"TypedefSpec",
":",
"return",
"g",
".",
"LookupTypeName",
"(",
"spec",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"spec",
",",
"spec",
")",
")",
"\n",
"}",
"\n",
"}"
] |
// typeName returns the name of the given type, whether it's a custom type or
// native.
|
[
"typeName",
"returns",
"the",
"name",
"of",
"the",
"given",
"type",
"whether",
"it",
"s",
"a",
"custom",
"type",
"or",
"native",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/type.go#L132-L185
|
17,487 |
thriftrw/thriftrw-go
|
compile/service.go
|
resolveService
|
func resolveService(src ast.ServiceReference, scope Scope) (*ServiceSpec, error) {
s, err := scope.LookupService(src.Name)
if err == nil {
err = s.Link(scope)
return s, err
}
mname, iname := splitInclude(src.Name)
if len(mname) == 0 {
return nil, referenceError{
Target: src.Name,
Line: src.Line,
ScopeName: scope.GetName(),
Reason: err,
}
}
includedScope, err := getIncludedScope(scope, mname)
if err != nil {
return nil, referenceError{
Target: src.Name,
Line: src.Line,
ScopeName: scope.GetName(),
Reason: err,
}
}
return resolveService(ast.ServiceReference{Name: iname}, includedScope)
}
|
go
|
func resolveService(src ast.ServiceReference, scope Scope) (*ServiceSpec, error) {
s, err := scope.LookupService(src.Name)
if err == nil {
err = s.Link(scope)
return s, err
}
mname, iname := splitInclude(src.Name)
if len(mname) == 0 {
return nil, referenceError{
Target: src.Name,
Line: src.Line,
ScopeName: scope.GetName(),
Reason: err,
}
}
includedScope, err := getIncludedScope(scope, mname)
if err != nil {
return nil, referenceError{
Target: src.Name,
Line: src.Line,
ScopeName: scope.GetName(),
Reason: err,
}
}
return resolveService(ast.ServiceReference{Name: iname}, includedScope)
}
|
[
"func",
"resolveService",
"(",
"src",
"ast",
".",
"ServiceReference",
",",
"scope",
"Scope",
")",
"(",
"*",
"ServiceSpec",
",",
"error",
")",
"{",
"s",
",",
"err",
":=",
"scope",
".",
"LookupService",
"(",
"src",
".",
"Name",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"err",
"=",
"s",
".",
"Link",
"(",
"scope",
")",
"\n",
"return",
"s",
",",
"err",
"\n",
"}",
"\n\n",
"mname",
",",
"iname",
":=",
"splitInclude",
"(",
"src",
".",
"Name",
")",
"\n",
"if",
"len",
"(",
"mname",
")",
"==",
"0",
"{",
"return",
"nil",
",",
"referenceError",
"{",
"Target",
":",
"src",
".",
"Name",
",",
"Line",
":",
"src",
".",
"Line",
",",
"ScopeName",
":",
"scope",
".",
"GetName",
"(",
")",
",",
"Reason",
":",
"err",
",",
"}",
"\n",
"}",
"\n\n",
"includedScope",
",",
"err",
":=",
"getIncludedScope",
"(",
"scope",
",",
"mname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"referenceError",
"{",
"Target",
":",
"src",
".",
"Name",
",",
"Line",
":",
"src",
".",
"Line",
",",
"ScopeName",
":",
"scope",
".",
"GetName",
"(",
")",
",",
"Reason",
":",
"err",
",",
"}",
"\n",
"}",
"\n\n",
"return",
"resolveService",
"(",
"ast",
".",
"ServiceReference",
"{",
"Name",
":",
"iname",
"}",
",",
"includedScope",
")",
"\n",
"}"
] |
// resolveService resolves a ServiceReference in the given scope.
|
[
"resolveService",
"resolves",
"a",
"ServiceReference",
"in",
"the",
"given",
"scope",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L85-L113
|
17,488 |
thriftrw/thriftrw-go
|
compile/service.go
|
Link
|
func (s *ServiceSpec) Link(scope Scope) error {
if s.linked() {
return nil
}
if s.parentSrc != nil {
parent, err := resolveService(*s.parentSrc, scope)
if err != nil {
return compileError{
Target: s.Name,
Reason: referenceError{
Target: s.parentSrc.Name,
Line: s.parentSrc.Line,
ScopeName: scope.GetName(),
Reason: err,
},
}
}
if err := parent.Link(scope); err != nil {
return compileError{Target: s.Name, Reason: err}
}
s.Parent = parent
s.parentSrc = nil
}
for _, function := range s.Functions {
if err := function.Link(scope); err != nil {
return compileError{
Target: s.Name + "." + function.Name,
Reason: err,
}
}
}
return nil
}
|
go
|
func (s *ServiceSpec) Link(scope Scope) error {
if s.linked() {
return nil
}
if s.parentSrc != nil {
parent, err := resolveService(*s.parentSrc, scope)
if err != nil {
return compileError{
Target: s.Name,
Reason: referenceError{
Target: s.parentSrc.Name,
Line: s.parentSrc.Line,
ScopeName: scope.GetName(),
Reason: err,
},
}
}
if err := parent.Link(scope); err != nil {
return compileError{Target: s.Name, Reason: err}
}
s.Parent = parent
s.parentSrc = nil
}
for _, function := range s.Functions {
if err := function.Link(scope); err != nil {
return compileError{
Target: s.Name + "." + function.Name,
Reason: err,
}
}
}
return nil
}
|
[
"func",
"(",
"s",
"*",
"ServiceSpec",
")",
"Link",
"(",
"scope",
"Scope",
")",
"error",
"{",
"if",
"s",
".",
"linked",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"s",
".",
"parentSrc",
"!=",
"nil",
"{",
"parent",
",",
"err",
":=",
"resolveService",
"(",
"*",
"s",
".",
"parentSrc",
",",
"scope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"s",
".",
"Name",
",",
"Reason",
":",
"referenceError",
"{",
"Target",
":",
"s",
".",
"parentSrc",
".",
"Name",
",",
"Line",
":",
"s",
".",
"parentSrc",
".",
"Line",
",",
"ScopeName",
":",
"scope",
".",
"GetName",
"(",
")",
",",
"Reason",
":",
"err",
",",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"parent",
".",
"Link",
"(",
"scope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"s",
".",
"Name",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"s",
".",
"Parent",
"=",
"parent",
"\n",
"s",
".",
"parentSrc",
"=",
"nil",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"function",
":=",
"range",
"s",
".",
"Functions",
"{",
"if",
"err",
":=",
"function",
".",
"Link",
"(",
"scope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"s",
".",
"Name",
"+",
"\"",
"\"",
"+",
"function",
".",
"Name",
",",
"Reason",
":",
"err",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Link resolves any references made by the given service.
|
[
"Link",
"resolves",
"any",
"references",
"made",
"by",
"the",
"given",
"service",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L116-L153
|
17,489 |
thriftrw/thriftrw-go
|
compile/service.go
|
Link
|
func (f *FunctionSpec) Link(scope Scope) error {
if f.linked() {
return nil
}
if err := f.ArgsSpec.Link(scope); err != nil {
return compileError{Target: f.Name, Reason: err}
}
if f.ResultSpec != nil {
if err := f.ResultSpec.Link(scope); err != nil {
return compileError{Target: f.Name, Reason: err}
}
}
return nil
}
|
go
|
func (f *FunctionSpec) Link(scope Scope) error {
if f.linked() {
return nil
}
if err := f.ArgsSpec.Link(scope); err != nil {
return compileError{Target: f.Name, Reason: err}
}
if f.ResultSpec != nil {
if err := f.ResultSpec.Link(scope); err != nil {
return compileError{Target: f.Name, Reason: err}
}
}
return nil
}
|
[
"func",
"(",
"f",
"*",
"FunctionSpec",
")",
"Link",
"(",
"scope",
"Scope",
")",
"error",
"{",
"if",
"f",
".",
"linked",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"f",
".",
"ArgsSpec",
".",
"Link",
"(",
"scope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"f",
".",
"Name",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"if",
"f",
".",
"ResultSpec",
"!=",
"nil",
"{",
"if",
"err",
":=",
"f",
".",
"ResultSpec",
".",
"Link",
"(",
"scope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"f",
".",
"Name",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Link resolves any references made by the given function.
|
[
"Link",
"resolves",
"any",
"references",
"made",
"by",
"the",
"given",
"function",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L217-L233
|
17,490 |
thriftrw/thriftrw-go
|
compile/service.go
|
CallType
|
func (f *FunctionSpec) CallType() wire.EnvelopeType {
if f.OneWay {
return wire.OneWay
}
return wire.Call
}
|
go
|
func (f *FunctionSpec) CallType() wire.EnvelopeType {
if f.OneWay {
return wire.OneWay
}
return wire.Call
}
|
[
"func",
"(",
"f",
"*",
"FunctionSpec",
")",
"CallType",
"(",
")",
"wire",
".",
"EnvelopeType",
"{",
"if",
"f",
".",
"OneWay",
"{",
"return",
"wire",
".",
"OneWay",
"\n",
"}",
"\n",
"return",
"wire",
".",
"Call",
"\n",
"}"
] |
// CallType returns the envelope type that is used when making enveloped
// requests for this function.
|
[
"CallType",
"returns",
"the",
"envelope",
"type",
"that",
"is",
"used",
"when",
"making",
"enveloped",
"requests",
"for",
"this",
"function",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L242-L247
|
17,491 |
thriftrw/thriftrw-go
|
compile/service.go
|
Link
|
func (as ArgsSpec) Link(scope Scope) error {
return FieldGroup(as).Link(scope)
}
|
go
|
func (as ArgsSpec) Link(scope Scope) error {
return FieldGroup(as).Link(scope)
}
|
[
"func",
"(",
"as",
"ArgsSpec",
")",
"Link",
"(",
"scope",
"Scope",
")",
"error",
"{",
"return",
"FieldGroup",
"(",
"as",
")",
".",
"Link",
"(",
"scope",
")",
"\n",
"}"
] |
// Link resolves references made by the ArgsSpec.
|
[
"Link",
"resolves",
"references",
"made",
"by",
"the",
"ArgsSpec",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L261-L263
|
17,492 |
thriftrw/thriftrw-go
|
compile/service.go
|
Link
|
func (rs *ResultSpec) Link(scope Scope) (err error) {
if rs.ReturnType != nil {
rs.ReturnType, err = rs.ReturnType.Link(scope)
if err != nil {
return err
}
}
if err := rs.Exceptions.Link(scope); err != nil {
return err
}
// verify that everything listed under throws is an exception.
for _, exception := range rs.Exceptions {
spec, ok := exception.Type.(*StructSpec)
if !ok || spec.Type != ast.ExceptionType {
return notAnExceptionError{
FieldName: exception.ThriftName(),
TypeName: spec.ThriftName(),
}
}
}
return nil
}
|
go
|
func (rs *ResultSpec) Link(scope Scope) (err error) {
if rs.ReturnType != nil {
rs.ReturnType, err = rs.ReturnType.Link(scope)
if err != nil {
return err
}
}
if err := rs.Exceptions.Link(scope); err != nil {
return err
}
// verify that everything listed under throws is an exception.
for _, exception := range rs.Exceptions {
spec, ok := exception.Type.(*StructSpec)
if !ok || spec.Type != ast.ExceptionType {
return notAnExceptionError{
FieldName: exception.ThriftName(),
TypeName: spec.ThriftName(),
}
}
}
return nil
}
|
[
"func",
"(",
"rs",
"*",
"ResultSpec",
")",
"Link",
"(",
"scope",
"Scope",
")",
"(",
"err",
"error",
")",
"{",
"if",
"rs",
".",
"ReturnType",
"!=",
"nil",
"{",
"rs",
".",
"ReturnType",
",",
"err",
"=",
"rs",
".",
"ReturnType",
".",
"Link",
"(",
"scope",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"rs",
".",
"Exceptions",
".",
"Link",
"(",
"scope",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"// verify that everything listed under throws is an exception.",
"for",
"_",
",",
"exception",
":=",
"range",
"rs",
".",
"Exceptions",
"{",
"spec",
",",
"ok",
":=",
"exception",
".",
"Type",
".",
"(",
"*",
"StructSpec",
")",
"\n",
"if",
"!",
"ok",
"||",
"spec",
".",
"Type",
"!=",
"ast",
".",
"ExceptionType",
"{",
"return",
"notAnExceptionError",
"{",
"FieldName",
":",
"exception",
".",
"ThriftName",
"(",
")",
",",
"TypeName",
":",
"spec",
".",
"ThriftName",
"(",
")",
",",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"nil",
"\n",
"}"
] |
// Link resolves any references made by the return type or exceptions in the
// ResultSpec.
|
[
"Link",
"resolves",
"any",
"references",
"made",
"by",
"the",
"return",
"type",
"or",
"exceptions",
"in",
"the",
"ResultSpec",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/service.go#L301-L325
|
17,493 |
thriftrw/thriftrw-go
|
internal/semver/range.go
|
Contains
|
func (r *Range) Contains(other Version) bool {
return other.Compare(&r.Begin) >= 0 && other.Compare(&r.End) < 0
}
|
go
|
func (r *Range) Contains(other Version) bool {
return other.Compare(&r.Begin) >= 0 && other.Compare(&r.End) < 0
}
|
[
"func",
"(",
"r",
"*",
"Range",
")",
"Contains",
"(",
"other",
"Version",
")",
"bool",
"{",
"return",
"other",
".",
"Compare",
"(",
"&",
"r",
".",
"Begin",
")",
">=",
"0",
"&&",
"other",
".",
"Compare",
"(",
"&",
"r",
".",
"End",
")",
"<",
"0",
"\n",
"}"
] |
// Contains returns true if the given semver version number is in this range.
|
[
"Contains",
"returns",
"true",
"if",
"the",
"given",
"semver",
"version",
"number",
"is",
"in",
"this",
"range",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/internal/semver/range.go#L30-L32
|
17,494 |
thriftrw/thriftrw-go
|
gen/zap.go
|
zapMarshalerPtr
|
func (z *zapGenerator) zapMarshalerPtr(g Generator, spec compile.TypeSpec, fieldValue string) (string, error) {
if isPrimitiveType(spec) {
fieldValue = "*" + fieldValue
}
return z.zapMarshaler(g, spec, fieldValue)
}
|
go
|
func (z *zapGenerator) zapMarshalerPtr(g Generator, spec compile.TypeSpec, fieldValue string) (string, error) {
if isPrimitiveType(spec) {
fieldValue = "*" + fieldValue
}
return z.zapMarshaler(g, spec, fieldValue)
}
|
[
"func",
"(",
"z",
"*",
"zapGenerator",
")",
"zapMarshalerPtr",
"(",
"g",
"Generator",
",",
"spec",
"compile",
".",
"TypeSpec",
",",
"fieldValue",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"if",
"isPrimitiveType",
"(",
"spec",
")",
"{",
"fieldValue",
"=",
"\"",
"\"",
"+",
"fieldValue",
"\n",
"}",
"\n",
"return",
"z",
".",
"zapMarshaler",
"(",
"g",
",",
"spec",
",",
"fieldValue",
")",
"\n",
"}"
] |
// zapMarshalerPtr will dereference the pointer and call zapMarshal on it.
|
[
"zapMarshalerPtr",
"will",
"dereference",
"the",
"pointer",
"and",
"call",
"zapMarshal",
"on",
"it",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/zap.go#L134-L139
|
17,495 |
thriftrw/thriftrw-go
|
compile/compiler.go
|
Compile
|
func Compile(path string, opts ...Option) (*Module, error) {
c := newCompiler()
for _, opt := range opts {
opt(&c)
}
m, err := c.load(path)
if err != nil {
return nil, err
}
err = m.Walk(func(m *Module) error {
if err := c.link(m); err != nil {
return compileError{
Target: m.ThriftPath,
Reason: err,
}
}
return nil
})
return m, err
}
|
go
|
func Compile(path string, opts ...Option) (*Module, error) {
c := newCompiler()
for _, opt := range opts {
opt(&c)
}
m, err := c.load(path)
if err != nil {
return nil, err
}
err = m.Walk(func(m *Module) error {
if err := c.link(m); err != nil {
return compileError{
Target: m.ThriftPath,
Reason: err,
}
}
return nil
})
return m, err
}
|
[
"func",
"Compile",
"(",
"path",
"string",
",",
"opts",
"...",
"Option",
")",
"(",
"*",
"Module",
",",
"error",
")",
"{",
"c",
":=",
"newCompiler",
"(",
")",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"&",
"c",
")",
"\n",
"}",
"\n\n",
"m",
",",
"err",
":=",
"c",
".",
"load",
"(",
"path",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"m",
".",
"Walk",
"(",
"func",
"(",
"m",
"*",
"Module",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"link",
"(",
"m",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"compileError",
"{",
"Target",
":",
"m",
".",
"ThriftPath",
",",
"Reason",
":",
"err",
",",
"}",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}",
")",
"\n",
"return",
"m",
",",
"err",
"\n",
"}"
] |
// Compile parses and compiles the Thrift file at the given path and any other
// Thrift file it includes.
|
[
"Compile",
"parses",
"and",
"compiles",
"the",
"Thrift",
"file",
"at",
"the",
"given",
"path",
"and",
"any",
"other",
"Thrift",
"file",
"it",
"includes",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/compiler.go#L32-L53
|
17,496 |
thriftrw/thriftrw-go
|
compile/compiler.go
|
load
|
func (c compiler) load(p string) (*Module, error) {
p, err := c.fs.Abs(p)
if err != nil {
return nil, err
}
if m, ok := c.Modules[p]; ok {
// Already loaded.
return m, nil
}
s, err := c.fs.Read(p)
if err != nil {
return nil, fileReadError{Path: p, Reason: err}
}
prog, err := idl.Parse(s)
if err != nil {
return nil, parseError{Path: p, Reason: err}
}
m := &Module{
Name: fileBaseName(p),
ThriftPath: p,
Includes: make(map[string]*IncludedModule),
Constants: make(map[string]*Constant),
Types: make(map[string]TypeSpec),
Services: make(map[string]*ServiceSpec),
}
m.Raw = s
c.Modules[p] = m
// the module is added to the map before processing includes to break
// cyclic includes.
if err := c.gather(m, prog); err != nil {
return nil, fileCompileError{Path: p, Reason: err}
}
return m, nil
}
|
go
|
func (c compiler) load(p string) (*Module, error) {
p, err := c.fs.Abs(p)
if err != nil {
return nil, err
}
if m, ok := c.Modules[p]; ok {
// Already loaded.
return m, nil
}
s, err := c.fs.Read(p)
if err != nil {
return nil, fileReadError{Path: p, Reason: err}
}
prog, err := idl.Parse(s)
if err != nil {
return nil, parseError{Path: p, Reason: err}
}
m := &Module{
Name: fileBaseName(p),
ThriftPath: p,
Includes: make(map[string]*IncludedModule),
Constants: make(map[string]*Constant),
Types: make(map[string]TypeSpec),
Services: make(map[string]*ServiceSpec),
}
m.Raw = s
c.Modules[p] = m
// the module is added to the map before processing includes to break
// cyclic includes.
if err := c.gather(m, prog); err != nil {
return nil, fileCompileError{Path: p, Reason: err}
}
return m, nil
}
|
[
"func",
"(",
"c",
"compiler",
")",
"load",
"(",
"p",
"string",
")",
"(",
"*",
"Module",
",",
"error",
")",
"{",
"p",
",",
"err",
":=",
"c",
".",
"fs",
".",
"Abs",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"m",
",",
"ok",
":=",
"c",
".",
"Modules",
"[",
"p",
"]",
";",
"ok",
"{",
"// Already loaded.",
"return",
"m",
",",
"nil",
"\n",
"}",
"\n\n",
"s",
",",
"err",
":=",
"c",
".",
"fs",
".",
"Read",
"(",
"p",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fileReadError",
"{",
"Path",
":",
"p",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"prog",
",",
"err",
":=",
"idl",
".",
"Parse",
"(",
"s",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"parseError",
"{",
"Path",
":",
"p",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"m",
":=",
"&",
"Module",
"{",
"Name",
":",
"fileBaseName",
"(",
"p",
")",
",",
"ThriftPath",
":",
"p",
",",
"Includes",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"IncludedModule",
")",
",",
"Constants",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"Constant",
")",
",",
"Types",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"TypeSpec",
")",
",",
"Services",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"ServiceSpec",
")",
",",
"}",
"\n\n",
"m",
".",
"Raw",
"=",
"s",
"\n",
"c",
".",
"Modules",
"[",
"p",
"]",
"=",
"m",
"\n",
"// the module is added to the map before processing includes to break",
"// cyclic includes.",
"if",
"err",
":=",
"c",
".",
"gather",
"(",
"m",
",",
"prog",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fileCompileError",
"{",
"Path",
":",
"p",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n",
"return",
"m",
",",
"nil",
"\n",
"}"
] |
// load populates the compiler with information from the given Thrift file.
//
// The types aren't actually compiled in this step.
|
[
"load",
"populates",
"the",
"compiler",
"with",
"information",
"from",
"the",
"given",
"Thrift",
"file",
".",
"The",
"types",
"aren",
"t",
"actually",
"compiled",
"in",
"this",
"step",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/compiler.go#L119-L158
|
17,497 |
thriftrw/thriftrw-go
|
compile/compiler.go
|
include
|
func (c compiler) include(m *Module, include *ast.Include) (*IncludedModule, error) {
if len(include.Name) > 0 {
// TODO(abg): Add support for include-as flag somewhere.
return nil, includeError{
Include: include,
Reason: includeAsDisabledError{},
}
}
ipath := filepath.Join(filepath.Dir(m.ThriftPath), include.Path)
incM, err := c.load(ipath)
if err != nil {
return nil, includeError{Include: include, Reason: err}
}
return &IncludedModule{Name: fileBaseName(include.Path), Module: incM}, nil
}
|
go
|
func (c compiler) include(m *Module, include *ast.Include) (*IncludedModule, error) {
if len(include.Name) > 0 {
// TODO(abg): Add support for include-as flag somewhere.
return nil, includeError{
Include: include,
Reason: includeAsDisabledError{},
}
}
ipath := filepath.Join(filepath.Dir(m.ThriftPath), include.Path)
incM, err := c.load(ipath)
if err != nil {
return nil, includeError{Include: include, Reason: err}
}
return &IncludedModule{Name: fileBaseName(include.Path), Module: incM}, nil
}
|
[
"func",
"(",
"c",
"compiler",
")",
"include",
"(",
"m",
"*",
"Module",
",",
"include",
"*",
"ast",
".",
"Include",
")",
"(",
"*",
"IncludedModule",
",",
"error",
")",
"{",
"if",
"len",
"(",
"include",
".",
"Name",
")",
">",
"0",
"{",
"// TODO(abg): Add support for include-as flag somewhere.",
"return",
"nil",
",",
"includeError",
"{",
"Include",
":",
"include",
",",
"Reason",
":",
"includeAsDisabledError",
"{",
"}",
",",
"}",
"\n",
"}",
"\n\n",
"ipath",
":=",
"filepath",
".",
"Join",
"(",
"filepath",
".",
"Dir",
"(",
"m",
".",
"ThriftPath",
")",
",",
"include",
".",
"Path",
")",
"\n",
"incM",
",",
"err",
":=",
"c",
".",
"load",
"(",
"ipath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"includeError",
"{",
"Include",
":",
"include",
",",
"Reason",
":",
"err",
"}",
"\n",
"}",
"\n\n",
"return",
"&",
"IncludedModule",
"{",
"Name",
":",
"fileBaseName",
"(",
"include",
".",
"Path",
")",
",",
"Module",
":",
"incM",
"}",
",",
"nil",
"\n",
"}"
] |
// include loads the file specified by the given include in the given Module.
//
// The path to the file is relative to the ThriftPath of the given module.
|
[
"include",
"loads",
"the",
"file",
"specified",
"by",
"the",
"given",
"include",
"in",
"the",
"given",
"Module",
".",
"The",
"path",
"to",
"the",
"file",
"is",
"relative",
"to",
"the",
"ThriftPath",
"of",
"the",
"given",
"module",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/compile/compiler.go#L245-L261
|
17,498 |
thriftrw/thriftrw-go
|
gen/list.go
|
zapMarshaler
|
func (l *listGenerator) zapMarshaler(
g Generator,
spec *compile.ListSpec,
fieldValue string,
) (string, error) {
name := zapperName(g, spec)
if err := g.EnsureDeclared(
`
<$zapcore := import "go.uber.org/zap/zapcore">
type <.Name> <typeReference .Type>
<$l := newVar "l">
<$v := newVar "v">
<$enc := newVar "enc">
// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of <.Name>.
func (<$l> <.Name>) MarshalLogArray(<$enc> <$zapcore>.ArrayEncoder) (err error) {
for _, <$v> := range <$l> {
<zapEncodeBegin .Type.ValueSpec ->
<$enc>.Append<zapEncoder .Type.ValueSpec>(<zapMarshaler .Type.ValueSpec $v>)
<- zapEncodeEnd .Type.ValueSpec>
}
return err
}
`, struct {
Name string
Type *compile.ListSpec
}{
Name: name,
Type: spec,
},
); err != nil {
return "", err
}
return fmt.Sprintf("(%v)(%v)", name, fieldValue), nil
}
|
go
|
func (l *listGenerator) zapMarshaler(
g Generator,
spec *compile.ListSpec,
fieldValue string,
) (string, error) {
name := zapperName(g, spec)
if err := g.EnsureDeclared(
`
<$zapcore := import "go.uber.org/zap/zapcore">
type <.Name> <typeReference .Type>
<$l := newVar "l">
<$v := newVar "v">
<$enc := newVar "enc">
// MarshalLogArray implements zapcore.ArrayMarshaler, enabling
// fast logging of <.Name>.
func (<$l> <.Name>) MarshalLogArray(<$enc> <$zapcore>.ArrayEncoder) (err error) {
for _, <$v> := range <$l> {
<zapEncodeBegin .Type.ValueSpec ->
<$enc>.Append<zapEncoder .Type.ValueSpec>(<zapMarshaler .Type.ValueSpec $v>)
<- zapEncodeEnd .Type.ValueSpec>
}
return err
}
`, struct {
Name string
Type *compile.ListSpec
}{
Name: name,
Type: spec,
},
); err != nil {
return "", err
}
return fmt.Sprintf("(%v)(%v)", name, fieldValue), nil
}
|
[
"func",
"(",
"l",
"*",
"listGenerator",
")",
"zapMarshaler",
"(",
"g",
"Generator",
",",
"spec",
"*",
"compile",
".",
"ListSpec",
",",
"fieldValue",
"string",
",",
")",
"(",
"string",
",",
"error",
")",
"{",
"name",
":=",
"zapperName",
"(",
"g",
",",
"spec",
")",
"\n",
"if",
"err",
":=",
"g",
".",
"EnsureDeclared",
"(",
"`\n\t\t\t<$zapcore := import \"go.uber.org/zap/zapcore\">\n\n\t\t\ttype <.Name> <typeReference .Type>\n\t\t\t<$l := newVar \"l\">\n\t\t\t<$v := newVar \"v\">\n\t\t\t<$enc := newVar \"enc\">\n\t\t\t// MarshalLogArray implements zapcore.ArrayMarshaler, enabling\n\t\t\t// fast logging of <.Name>.\n\t\t\tfunc (<$l> <.Name>) MarshalLogArray(<$enc> <$zapcore>.ArrayEncoder) (err error) {\n\t\t\t\tfor _, <$v> := range <$l> {\n\t\t\t\t\t<zapEncodeBegin .Type.ValueSpec ->\n\t\t\t\t\t\t<$enc>.Append<zapEncoder .Type.ValueSpec>(<zapMarshaler .Type.ValueSpec $v>)\n\t\t\t\t\t<- zapEncodeEnd .Type.ValueSpec>\n\t\t\t\t}\n\t\t\t\treturn err\n\t\t\t}\n\t\t\t`",
",",
"struct",
"{",
"Name",
"string",
"\n",
"Type",
"*",
"compile",
".",
"ListSpec",
"\n",
"}",
"{",
"Name",
":",
"name",
",",
"Type",
":",
"spec",
",",
"}",
",",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"err",
"\n",
"}",
"\n",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"name",
",",
"fieldValue",
")",
",",
"nil",
"\n",
"}"
] |
// Slices are logged as JSON arrays.
|
[
"Slices",
"are",
"logged",
"as",
"JSON",
"arrays",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/gen/list.go#L186-L221
|
17,499 |
thriftrw/thriftrw-go
|
plugin/api/servicegenerator_handler.go
|
Handle
|
func (h ServiceGeneratorHandler) Handle(name string, reqValue wire.Value) (wire.Value, error) {
switch name {
case "generate":
var args ServiceGenerator_Generate_Args
if err := args.FromWire(reqValue); err != nil {
return wire.Value{}, err
}
result, err := ServiceGenerator_Generate_Helper.WrapResponse(
h.impl.Generate(args.Request),
)
if err != nil {
return wire.Value{}, err
}
return result.ToWire()
default:
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
}
|
go
|
func (h ServiceGeneratorHandler) Handle(name string, reqValue wire.Value) (wire.Value, error) {
switch name {
case "generate":
var args ServiceGenerator_Generate_Args
if err := args.FromWire(reqValue); err != nil {
return wire.Value{}, err
}
result, err := ServiceGenerator_Generate_Helper.WrapResponse(
h.impl.Generate(args.Request),
)
if err != nil {
return wire.Value{}, err
}
return result.ToWire()
default:
return wire.Value{}, envelope.ErrUnknownMethod(name)
}
}
|
[
"func",
"(",
"h",
"ServiceGeneratorHandler",
")",
"Handle",
"(",
"name",
"string",
",",
"reqValue",
"wire",
".",
"Value",
")",
"(",
"wire",
".",
"Value",
",",
"error",
")",
"{",
"switch",
"name",
"{",
"case",
"\"",
"\"",
":",
"var",
"args",
"ServiceGenerator_Generate_Args",
"\n",
"if",
"err",
":=",
"args",
".",
"FromWire",
"(",
"reqValue",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"wire",
".",
"Value",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"result",
",",
"err",
":=",
"ServiceGenerator_Generate_Helper",
".",
"WrapResponse",
"(",
"h",
".",
"impl",
".",
"Generate",
"(",
"args",
".",
"Request",
")",
",",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"wire",
".",
"Value",
"{",
"}",
",",
"err",
"\n",
"}",
"\n\n",
"return",
"result",
".",
"ToWire",
"(",
")",
"\n\n",
"default",
":",
"return",
"wire",
".",
"Value",
"{",
"}",
",",
"envelope",
".",
"ErrUnknownMethod",
"(",
"name",
")",
"\n\n",
"}",
"\n",
"}"
] |
// Handle receives and handles a request for the ServiceGenerator service.
|
[
"Handle",
"receives",
"and",
"handles",
"a",
"request",
"for",
"the",
"ServiceGenerator",
"service",
"."
] |
a9a6ad793beab07cc3385954d2e8af8abfaa83e2
|
https://github.com/thriftrw/thriftrw-go/blob/a9a6ad793beab07cc3385954d2e8af8abfaa83e2/plugin/api/servicegenerator_handler.go#L44-L68
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.