_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q16100 | GetKeys | train | func (r *FastHttpHeader) GetKeys() (value []string) {
addValue := func(k, v []byte) {
found := false
key := string(k)
for _, r := range value {
if key == r {
found = true
break
}
}
if !found {
value = append(value, key)
}
}
if !r.isResponse {
r.Source.(*FastHttpRequest).Original.Reque... | go | {
"resource": ""
} |
q16101 | Get | train | func (r *FastHttpHeader) Get(key string) (value []string) {
if !r.isResponse {
value = strings.Split(string(r.Source.(*FastHttpRequest).Original.Request.Header.Peek(key)), ",")
} else {
value = strings.Split(string(r.Source.(*FastHttpResponse).Original.Response.Header.Peek(key)), ",")
}
return
} | go | {
"resource": ""
} |
q16102 | SetStatus | train | func (r *FastHttpHeader) SetStatus(statusCode int) {
if r.isResponse {
r.Source.(*FastHttpResponse).Original.Response.SetStatusCode(statusCode)
}
} | go | {
"resource": ""
} |
q16103 | GetValues | train | func (f *FastHttpMultipartForm) GetValues() url.Values {
return url.Values(f.Form.Value)
} | go | {
"resource": ""
} |
q16104 | Render | train | func (acetmpl AceTemplate) Render(wr io.Writer, arg interface{}) error {
// We can redirect this render to another template if the arguments contain ace_content in them
if argmap, ok := arg.(map[string]interface{}); ok {
if acecontentraw, ok := argmap["ace-inner"]; ok {
acecontent := acecontentraw.(string)
ne... | go | {
"resource": ""
} |
q16105 | Init | train | func Init() {
// Read configuration.
var found bool
if Driver, found = revel.Config.String("db.driver"); !found {
revel.RevelLog.Fatal("db.driver not configured")
}
if Spec, found = revel.Config.String("db.spec"); !found {
revel.RevelLog.Fatal("db.spec not configured")
}
// Open a connection.
var err error... | go | {
"resource": ""
} |
q16106 | InitDb | train | func InitDb(dbResult *DbGorp) error {
params := DbInfo{}
params.DbDriver = revel.Config.StringDefault("db.driver", "sqlite3")
params.DbHost = revel.Config.StringDefault("db.host", "localhost")
if params.DbDriver == "sqlite3" && params.DbHost == "localhost" {
params.DbHost = "/tmp/app.db"
}
params.DbUser = revel... | go | {
"resource": ""
} |
q16107 | validToken | train | func validToken(token string, isSameOrigin, foundToken bool, c *revel.Controller) (result bool) {
// Token wasn't present at all
if !foundToken {
c.Result = c.Forbidden("REVEL CSRF: Session token missing.")
return
}
// Same origin
if !isSameOrigin {
c.Result = c.Forbidden("REVEL CSRF: Same origin mismatch."... | go | {
"resource": ""
} |
q16108 | getFullRequestURL | train | func getFullRequestURL(c *revel.Controller) (requestUrl *url.URL) {
requestUrl = c.Request.URL
c.Log.Debug("Using ", "request url host", requestUrl.Host, "request host", c.Request.Host, "cookie domain", revel.CookieDomain)
// Update any of the information based on the headers
if host := c.Request.GetHttpHeader("X-... | go | {
"resource": ""
} |
q16109 | compareToken | train | func compareToken(requestToken, token string) bool {
// ConstantTimeCompare will panic if the []byte aren't the same length
if len(requestToken) != len(token) {
return false
}
return subtle.ConstantTimeCompare([]byte(requestToken), []byte(token)) == 1
} | go | {
"resource": ""
} |
q16110 | sameOrigin | train | func sameOrigin(u1, u2 *url.URL) bool {
return u1.Scheme == u2.Scheme && u1.Hostname() == u2.Hostname()
} | go | {
"resource": ""
} |
q16111 | init | train | func init() {
revel.TemplateFuncs["csrftoken"] = func(viewArgs map[string]interface{}) template.HTML {
if tokenFunc, ok := viewArgs["_csrftoken"]; !ok {
panic("REVEL CSRF: _csrftoken missing from ViewArgs.")
} else {
return template.HTML(tokenFunc.(string))
}
}
} | go | {
"resource": ""
} |
q16112 | NewAdapter | train | func NewAdapter(params gormdb.DbInfo) *Adapter {
a := &Adapter{}
gormdb.InitDBWithParameters(params)
a.db = gormdb.DB
return a
} | go | {
"resource": ""
} |
q16113 | LoadPolicy | train | func (a *Adapter) LoadPolicy(model model.Model) error {
var lines []Line
err := a.db.Find(&lines).Error
if err != nil {
return err
}
for _, line := range lines {
loadPolicyLine(line, model)
}
return nil
} | go | {
"resource": ""
} |
q16114 | SavePolicy | train | func (a *Adapter) SavePolicy(model model.Model) error {
a.dropTable()
a.createTable()
for ptype, ast := range model["p"] {
for _, rule := range ast.Policy {
line := savePolicyLine(ptype, rule)
err := a.db.Create(&line).Error
if err != nil {
return err
}
}
}
for ptype, ast := range model["g"] ... | go | {
"resource": ""
} |
q16115 | NewGracefulListener | train | func NewGracefulListener(ln net.Listener, maxWaitTime time.Duration) net.Listener {
return &GracefulListener{
ln: ln,
maxWaitTime: maxWaitTime,
done: make(chan struct{}),
}
} | go | {
"resource": ""
} |
q16116 | Close | train | func (ln *GracefulListener) Close() error {
err := ln.ln.Close()
if err != nil {
return nil
}
return ln.waitForZeroConns()
} | go | {
"resource": ""
} |
q16117 | Render | train | func (tmpl PongoTemplate) Render(wr io.Writer, arg interface{}) (err error) {
gls.With(gls.Values(map[interface{}]interface{}{"data": arg}), func() {
err = tmpl.template.ExecuteWriter(p2.Context(arg.(map[string]interface{})), wr)
if nil != err {
if e, ok := err.(*p2.Error); ok {
rerr := &revel.Error{
T... | go | {
"resource": ""
} |
q16118 | NewDbWorker | train | func NewDbWorker(db *DbGorp, workInfo DbWorkInfo, numWorkers int) (container *DbWorkerContainer) {
container = &DbWorkerContainer{
SharedWorker: SharedWorker{
InputChannel: make(chan interface{}, numWorkers),
OutputChannel: make(chan interface{}, numWorkers),
ControlChannel: make(chan func() (WorkerPhas... | go | {
"resource": ""
} |
q16119 | startWorker | train | func startWorker(container *DbWorkerContainer, db *DbGorp, id int) {
newDb, _ := db.CloneDb(true)
worker := &DbWorker{
Db: newDb,
Id: id,
SharedData: map[string]interface{}{},
SharedWorker: SharedWorker{
workInfo: container.workInfo,
InputChannel: container.InputChannel,
Outpu... | go | {
"resource": ""
} |
q16120 | start | train | func (worker *DbWorker) start() {
worker.workInfo.Status(Start, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { return Start, worker }
for job := range worker.InputChannel {
worker.invoke(job)
}
worker.workInfo.Status(Stop, worker)
worker.ControlChannel <- func() (WorkerPhase, *DbWorker) { re... | go | {
"resource": ""
} |
q16121 | invoke | train | func (worker *DbWorker) invoke(job interface{}) {
defer func() {
if err := recover(); err != nil {
trace := make([]byte, 1024)
count := runtime.Stack(trace, true)
moduleLogger.Error("Recover from panic: ", "error", err)
moduleLogger.Error("Stack", "size", count, "trace", string(trace))
}
}()
// Setup... | go | {
"resource": ""
} |
q16122 | MakeCallback | train | func MakeCallback(status func(phase WorkerPhase, worker *DbWorker), work func(value interface{}, worker *DbWorker)) DbWorkInfo {
return &DbCallbackImplied{StatusFn: status, WorkFn: work}
} | go | {
"resource": ""
} |
q16123 | Status | train | func (dbCallback *DbCallbackImplied) Status(phase WorkerPhase, worker *DbWorker) {
if dbCallback.StatusFn != nil {
dbCallback.StatusFn(phase, worker)
}
} | go | {
"resource": ""
} |
q16124 | Work | train | func (dbCallback *DbCallbackImplied) Work(value interface{}, worker *DbWorker) {
dbCallback.WorkFn(value, worker)
} | go | {
"resource": ""
} |
q16125 | start | train | func (_ *timeoutInfo) start(TimeoutChannel chan *timeoutInfo, timeout int64) {
for j := range TimeoutChannel {
j.started = time.Now()
j.state = StartJob
j.worker.workInfo.Status(j.state, j.worker)
for {
select {
case complete, ok := <-TimeoutChannel:
if !ok {
// Channel closed returning...
... | go | {
"resource": ""
} |
q16126 | CloneDb | train | func (dbGorp *DbGorp) CloneDb(open bool) (newDb *DbGorp, err error) {
dbInfo := *dbGorp.Info
newDb = &DbGorp{Info: &dbInfo}
newDb.dbInitFn = dbGorp.dbInitFn
err = newDb.InitDb(open)
return
} | go | {
"resource": ""
} |
q16127 | dbInit | train | func (dbGorp *DbGorp) dbInit() (err error) {
if dbGorp.dbInitFn != nil {
err = dbGorp.dbInitFn(dbGorp)
}
return
} | go | {
"resource": ""
} |
q16128 | SetDbInit | train | func (dbGorp *DbGorp) SetDbInit(dbInitFn func(dbMap *DbGorp) error) (err error) {
dbGorp.dbInitFn = dbInitFn
return dbGorp.dbInit()
} | go | {
"resource": ""
} |
q16129 | RenderAceTemplate | train | func (c *AceController) RenderAceTemplate(base, inner string) revel.Result {
c.ViewArgs["ace-inner"] = inner
return c.RenderTemplate(base)
} | go | {
"resource": ""
} |
q16130 | Begin | train | func (c *TxnController) Begin() revel.Result {
txn := gormdb.DB.Begin()
if txn.Error != nil {
c.Log.Panic("Transaction begine error", "error", txn.Error)
}
c.Txn = txn
return nil
} | go | {
"resource": ""
} |
q16131 | Commit | train | func (c *TxnController) Commit() revel.Result {
if c.Txn == nil {
return nil
}
c.Txn.Commit()
if c.Txn.Error != nil && c.Txn.Error != sql.ErrTxDone {
fmt.Println(c.Txn.Error)
panic(c.Txn.Error)
}
c.Txn = nil
return nil
} | go | {
"resource": ""
} |
q16132 | NewRelicFilter | train | func NewRelicFilter(c *revel.Controller, fc []revel.Filter) {
if nr, ok := revel.CurrentEngine.Engine().(*ServerNewRelic); ok {
if nr.NewRelicApp != nil {
txn := nr.NewRelicApp.StartTransaction(c.Action,
c.Response.Out.Server.(*revel.GoResponse).Original,
c.Request.In.(*revel.GoRequest).Original)
defer... | go | {
"resource": ""
} |
q16133 | ServeDir | train | func (c Static) ServeDir(prefix, filepath string) revel.Result {
// Fix for #503.
prefix = c.Params.Fixed.Get("prefix")
if prefix == "" {
return c.NotFound("")
}
return serve(c, prefix, filepath, true)
} | go | {
"resource": ""
} |
q16134 | processDir | train | func (c *Static) processDir(fullPath, basePath string) (args map[string]interface{}, err error) {
dirName := fpath.Base(fullPath)
args = map[string]interface{}{"dirName": dirName}
// Walk the folder showing up and down links
dirFiles := []model.FileInformation{}
symLinkPath, e := fpath.EvalSymlinks(fullPath)
if e... | go | {
"resource": ""
} |
q16135 | S3Endpoint | train | func (c *S3Cli) S3Endpoint() string {
if c.Host == "" {
return ""
}
if c.Port != 0 {
return fmt.Sprintf("%s:%d", c.Host, c.Port)
}
return c.Host
} | go | {
"resource": ""
} |
q16136 | AssertPutOptionsApplied | train | func AssertPutOptionsApplied(s3CLIPath string, cfg *config.S3Cli) {
expectedString := GenerateRandomString()
s3Filename := GenerateRandomString()
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
contentFile := MakeContentFile(expectedString)
defer func() { _ = os.Remove(contentFile... | go | {
"resource": ""
} |
q16137 | AssertGetNonexistentFails | train | func AssertGetNonexistentFails(s3CLIPath string, cfg *config.S3Cli) {
configPath := MakeConfigFile(cfg)
defer func() { _ = os.Remove(configPath) }()
s3CLISession, err := RunS3CLI(s3CLIPath, configPath, "get", "non-existent-file", "/dev/null")
Expect(err).ToNot(HaveOccurred())
Expect(s3CLISession.ExitCode()).ToNot... | go | {
"resource": ""
} |
q16138 | New | train | func New(s3Client *s3.S3, s3cliConfig *config.S3Cli) (S3Blobstore, error) {
return S3Blobstore{s3Client: s3Client, s3cliConfig: s3cliConfig}, nil
} | go | {
"resource": ""
} |
q16139 | Get | train | func (client *S3Blobstore) Get(src string, dest io.WriterAt) error {
downloader := s3manager.NewDownloaderWithClient(client.s3Client)
_, err := downloader.Download(dest, &s3.GetObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(src),
})
if err != nil {
return err
}
return ... | go | {
"resource": ""
} |
q16140 | Put | train | func (client *S3Blobstore) Put(src io.ReadSeeker, dest string) error {
cfg := client.s3cliConfig
if cfg.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
uploader := s3manager.NewUploaderWithClient(client.s3Client, func(u *s3manager.Uploader) {
u.LeavePartsOnError ... | go | {
"resource": ""
} |
q16141 | Delete | train | func (client *S3Blobstore) Delete(dest string) error {
if client.s3cliConfig.CredentialsSource == config.NoneCredentialsSource {
return errorInvalidCredentialsSourceValue
}
deleteParams := &s3.DeleteObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client... | go | {
"resource": ""
} |
q16142 | Exists | train | func (client *S3Blobstore) Exists(dest string) (bool, error) {
existsParams := &s3.HeadObjectInput{
Bucket: aws.String(client.s3cliConfig.BucketName),
Key: client.key(dest),
}
_, err := client.s3Client.HeadObject(existsParams)
if err == nil {
log.Printf("File '%s' exists in bucket '%s'\n", dest, client.... | go | {
"resource": ""
} |
q16143 | PackageXml | train | func (pb PackageBuilder) PackageXml() []byte {
p := createPackage()
for _, metaType := range pb.Metadata {
p.Types = append(p.Types, metaType)
}
byteXml, _ := xml.MarshalIndent(p, "", " ")
byteXml = append([]byte(xml.Header), byteXml...)
//if err := ioutil.WriteFile("mypackage.xml", byteXml, 0644); err != ... | go | {
"resource": ""
} |
q16144 | ForceMetadataFiles | train | func (pb *PackageBuilder) ForceMetadataFiles() ForceMetadataFiles {
pb.Files["package.xml"] = pb.PackageXml()
return pb.Files
} | go | {
"resource": ""
} |
q16145 | MetaPathToSourcePath | train | func MetaPathToSourcePath(mpath string) (spath string) {
spath = strings.TrimSuffix(mpath, "-meta.xml")
if spath == mpath {
return
}
_, err := os.Stat(spath)
if err != nil {
spath = mpath
}
return
} | go | {
"resource": ""
} |
q16146 | AddFile | train | func (pb *PackageBuilder) AddFile(fpath string) (fname string, err error) {
fpath, err = filepath.Abs(fpath)
if err != nil {
return
}
_, err = os.Stat(fpath)
if err != nil {
return
}
isDestructiveChanges, err := regexp.MatchString("destructiveChanges(Pre|Post)?"+regexp.QuoteMeta(".")+"xml", fpath)
if err !... | go | {
"resource": ""
} |
q16147 | AddDirectory | train | func (pb *PackageBuilder) AddDirectory(fpath string) (namePaths map[string]string, badPaths []string, err error) {
namePaths = make(map[string]string)
files, err := ioutil.ReadDir(fpath)
if err != nil {
badPaths = append(badPaths, fpath)
return
}
for _, f := range files {
dirOrFilePath := fpath + "/" + f.N... | go | {
"resource": ""
} |
q16148 | addFileToWorkingDir | train | func (pb *PackageBuilder) addFileToWorkingDir(metaName string, fpath string) (err error) {
// Get relative dir from source
srcDir := filepath.Dir(filepath.Dir(fpath))
for _, mp := range metapaths {
if metaName == mp.name && mp.hasFolder {
srcDir = filepath.Dir(srcDir)
}
}
frel, _ := filepath.Rel(srcDir, fpa... | go | {
"resource": ""
} |
q16149 | AddMetaToPackage | train | func (pb *PackageBuilder) AddMetaToPackage(metaName string, name string) {
mt := pb.Metadata[metaName]
if mt.Name == "" {
mt.Name = metaName
}
if !pb.contains(mt.Members, name) {
mt.Members = append(mt.Members, name)
pb.Metadata[metaName] = mt
}
} | go | {
"resource": ""
} |
q16150 | getMetaTypeFromPath | train | func getMetaTypeFromPath(fpath string) (metaName string, name string) {
fpath, err := filepath.Abs(fpath)
if err != nil {
ErrorAndExit("Cound not find " + fpath)
}
if _, err := os.Stat(fpath); err != nil {
ErrorAndExit("Cound not open " + fpath)
}
// Get the metadata type and name for the file
metaName, fil... | go | {
"resource": ""
} |
q16151 | getMetaForPath | train | func getMetaForPath(path string) (metaName string, objectName string) {
parentDir := filepath.Dir(path)
parentName := filepath.Base(parentDir)
grandparentName := filepath.Base(filepath.Dir(parentDir))
fileName := filepath.Base(path)
for _, mp := range metapaths {
if mp.hasFolder && grandparentName == mp.path {
... | go | {
"resource": ""
} |
q16152 | getMDTypeFromXml | train | func getMDTypeFromXml(path string) (mdtype string, err error) {
xmlFile, err := ioutil.ReadFile(path)
mdtype = getFirstXmlElement(xmlFile)
return
} | go | {
"resource": ""
} |
q16153 | getFirstXmlElement | train | func getFirstXmlElement(xmlFile []byte) (firstElement string) {
decoder := xml.NewDecoder(strings.NewReader(string(xmlFile)))
for {
token, _ := decoder.Token()
if token == nil {
break
}
switch startElement := token.(type) {
case xml.StartElement:
firstElement = startElement.Name.Local
return
}
}... | go | {
"resource": ""
} |
q16154 | findMetadataTypeFolder | train | func findMetadataTypeFolder(mdtype string, root string) (folder string) {
filepath.Walk(root, func(path string, f os.FileInfo, err error) error {
firstEl, _ := getMDTypeFromXml(path)
if firstEl == mdtype {
// This is sufficient for MD that does not have sub folders (classes, pages, etc)
// It is NOT sufficie... | go | {
"resource": ""
} |
q16155 | zipResource | train | func zipResource(path string, topLevelFolder string) {
zipfile := new(bytes.Buffer)
zipper := zip.NewWriter(zipfile)
startPath := path + "/"
filepath.Walk(path, func(path string, f os.FileInfo, err error) error {
if strings.ToLower(filepath.Base(path)) != ".ds_store" {
// Can skip dirs since the dirs will be c... | go | {
"resource": ""
} |
q16156 | ForceSaveLogin | train | func ForceSaveLogin(creds ForceSession, output *os.File) (sessionName string, err error) {
userinfo, err := getUserInfo(creds)
if err != nil {
return
}
creds.UserInfo = &userinfo
creds.SessionOptions.ApiVersion = ApiVersionNumber()
fmt.Fprintf(output, "Logged in as '%s' (API %s)\n", creds.UserInfo.UserName, Ap... | go | {
"resource": ""
} |
q16157 | upgradeCredentials | train | func upgradeCredentials(creds *ForceSession) (err error) {
if creds.SessionOptions != nil && creds.UserInfo != nil {
return
}
if creds.SessionOptions == nil {
creds.SessionOptions = &SessionOptions{
ApiVersion: ApiVersionNumber(),
}
if creds.RefreshToken != "" {
creds.SessionOptions.RefreshMethod = Ref... | go | {
"resource": ""
} |
q16158 | getAttributes | train | func getAttributes(m interface{}) map[string]reflect.StructField {
typ := reflect.TypeOf(m)
// if a pointer to a struct is passed, get the type of the dereferenced object
if typ.Kind() == reflect.Ptr {
typ = typ.Elem()
}
// create an attribute data structure as a map of types keyed by a string.
attrs := make(m... | go | {
"resource": ""
} |
q16159 | PushByPaths | train | func PushByPaths(fpaths []string, byName bool, namePaths map[string]string, opts *ForceDeployOptions) {
pb := NewPushBuilder()
var badPaths []string
for _, fpath := range fpaths {
fi, err := os.Stat(fpath)
if err != nil {
fmt.Println(err)
badPaths = append(badPaths, fpath)
continue
}
mode := fi.Mo... | go | {
"resource": ""
} |
q16160 | processDeployResults | train | func processDeployResults(result ForceCheckDeploymentStatusResult, byName bool, namePaths map[string]string, deployErr error) (err error) {
if deployErr != nil {
ErrorAndExit(deployErr.Error())
}
problems := result.Details.ComponentFailures
successes := result.Details.ComponentSuccesses
testFailures := result.D... | go | {
"resource": ""
} |
q16161 | qualifyUrl | train | func (f *Force) qualifyUrl(url string) string {
return fmt.Sprintf("%s/%s", f.Credentials.InstanceUrl, strings.TrimLeft(url, "/"))
} | go | {
"resource": ""
} |
q16162 | IsSourceDir | train | func IsSourceDir(dir string) bool {
if _, err := os.Stat(dir); err == nil {
return true
}
return false
} | go | {
"resource": ""
} |
q16163 | GetSourceDir | train | func GetSourceDir() (dir string, err error) {
base, err := os.Getwd()
if err != nil {
return
}
// Look down to our nearest subdirectories
for _, src := range sourceDirs {
if len(src) > 0 {
dir = filepath.Join(base, src)
if IsSourceDir(dir) {
return
}
}
}
// Check the current directory and th... | go | {
"resource": ""
} |
q16164 | StringSlicePos | train | func StringSlicePos(slice []string, value string) int {
for p, v := range slice {
if v == value {
return p
}
}
return -1
} | go | {
"resource": ""
} |
q16165 | Group | train | func (p *DefaultTokenGrouper) Group(tokens []*Token) [][2]*Token {
if len(tokens) == 0 {
return nil
}
pairTokens := make([][2]*Token, 0, len(tokens))
prevToken := tokens[0]
for _, tok := range tokens {
if prevToken == tok {
continue
}
pairTokens = append(pairTokens, [2]*Token{prevToken, tok})
prevTo... | go | {
"resource": ""
} |
q16166 | NewToken | train | func NewToken(token string) *Token {
tok := Token{
Tok: token,
reEllipsis: reEllipsis,
reNumeric: reNumeric,
reInitial: reInitial,
reAlpha: reAlpha,
}
return &tok
} | go | {
"resource": ""
} |
q16167 | String | train | func (p *Token) String() string {
return fmt.Sprintf("<Token Tok: %q, SentBreak: %t, Abbr: %t, Position: %d>", p.Tok, p.SentBreak, p.Abbr, p.Position)
} | go | {
"resource": ""
} |
q16168 | N | train | func (f *FreqDist) N() float64 {
sum := 0.0
for _, val := range f.Samples {
sum += float64(val)
}
return sum
} | go | {
"resource": ""
} |
q16169 | rToNr | train | func (f *FreqDist) rToNr(bins int) map[int]int {
tmpRToNr := map[int]int{}
for _, value := range f.Samples {
tmpRToNr[value] += 1
}
if bins == 0 {
tmpRToNr[0] = 0
} else {
tmpRToNr[0] = bins - f.B()
}
return tmpRToNr
} | go | {
"resource": ""
} |
q16170 | cumulativeFrequencies | train | func (f *FreqDist) cumulativeFrequencies(Samples []string) []int {
cf := make([]int, 0, len(f.Samples))
for _, val := range Samples {
cf = append(cf, f.Samples[val])
}
return cf
} | go | {
"resource": ""
} |
q16171 | HasSentencePunct | train | func (p *DefaultPunctStrings) HasSentencePunct(text string) bool {
endPunct := `.!?`
for _, char := range endPunct {
for _, achar := range text {
if char == achar {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q16172 | NewTypeBasedAnnotation | train | func NewTypeBasedAnnotation(s *Storage, p PunctStrings, e TokenExistential) *TypeBasedAnnotation {
return &TypeBasedAnnotation{
Storage: s,
PunctStrings: p,
TokenExistential: e,
}
} | go | {
"resource": ""
} |
q16173 | NewAnnotations | train | func NewAnnotations(s *Storage, p PunctStrings, word WordTokenizer) []AnnotateTokens {
return []AnnotateTokens{
&TypeBasedAnnotation{s, p, word},
&TokenBasedAnnotation{s, p, word, &DefaultTokenGrouper{}, &OrthoContext{
s, p, word, word,
}},
}
} | go | {
"resource": ""
} |
q16174 | Annotate | train | func (a *TypeBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, augTok := range tokens {
a.typeAnnotation(augTok)
}
return tokens
} | go | {
"resource": ""
} |
q16175 | Annotate | train | func (a *TokenBasedAnnotation) Annotate(tokens []*Token) []*Token {
for _, tokPair := range a.TokenGrouper.Group(tokens) {
a.tokenAnnotation(tokPair[0], tokPair[1])
}
return tokens
} | go | {
"resource": ""
} |
q16176 | NewSentenceTokenizer | train | func NewSentenceTokenizer(s *Storage) *DefaultSentenceTokenizer {
lang := NewPunctStrings()
word := NewWordTokenizer(lang)
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
retur... | go | {
"resource": ""
} |
q16177 | NewTokenizer | train | func NewTokenizer(s *Storage, word WordTokenizer, lang PunctStrings) *DefaultSentenceTokenizer {
annotations := NewAnnotations(s, lang, word)
tokenizer := &DefaultSentenceTokenizer{
Storage: s,
PunctStrings: lang,
WordTokenizer: word,
Annotations: annotations,
}
return tokenizer
} | go | {
"resource": ""
} |
q16178 | Tokenize | train | func (s *DefaultSentenceTokenizer) Tokenize(text string) []*Sentence {
annotatedTokens := s.AnnotatedTokens(text)
lastBreak := 0
sentences := make([]*Sentence, 0, len(annotatedTokens))
for _, token := range annotatedTokens {
if !token.SentBreak {
continue
}
sentence := &Sentence{lastBreak, token.Position... | go | {
"resource": ""
} |
q16179 | HasSentEndChars | train | func (e *WordTokenizer) HasSentEndChars(t *sentences.Token) bool {
enders := []string{
`."`, `.'`, `.)`, `.’`, `.”`,
`?`, `?"`, `?'`, `?)`, `?’`, `?”`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`,... | go | {
"resource": ""
} |
q16180 | Tokenize | train | func (p *DefaultWordTokenizer) Tokenize(text string, onlyPeriodContext bool) []*Token {
textLength := len(text)
if textLength == 0 {
return nil
}
tokens := make([]*Token, 0, 50)
lastSpace := 0
lineStart := false
paragraphStart := false
getNextWord := false
for i, char := range text {
if !unicode.IsSpace... | go | {
"resource": ""
} |
q16181 | Type | train | func (p *DefaultWordTokenizer) Type(t *Token) string {
typ := t.reNumeric.ReplaceAllString(strings.ToLower(t.Tok), "##number##")
if len(typ) == 1 {
return typ
}
// removing comma from typ
return strings.Replace(typ, ",", "", -1)
} | go | {
"resource": ""
} |
q16182 | TypeNoPeriod | train | func (p *DefaultWordTokenizer) TypeNoPeriod(t *Token) string {
typ := p.Type(t)
if len(typ) > 1 && string(typ[len(typ)-1]) == "." {
return string(typ[:len(typ)-1])
}
return typ
} | go | {
"resource": ""
} |
q16183 | TypeNoSentPeriod | train | func (p *DefaultWordTokenizer) TypeNoSentPeriod(t *Token) string {
if p == nil {
return ""
}
if t.SentBreak {
return p.TypeNoPeriod(t)
}
return p.Type(t)
} | go | {
"resource": ""
} |
q16184 | FirstUpper | train | func (p *DefaultWordTokenizer) FirstUpper(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsUpper(runes[0])
} | go | {
"resource": ""
} |
q16185 | FirstLower | train | func (p *DefaultWordTokenizer) FirstLower(t *Token) bool {
if t.Tok == "" {
return false
}
runes := []rune(t.Tok)
return unicode.IsLower(runes[0])
} | go | {
"resource": ""
} |
q16186 | IsEllipsis | train | func (p *DefaultWordTokenizer) IsEllipsis(t *Token) bool {
return t.reEllipsis.MatchString(t.Tok)
} | go | {
"resource": ""
} |
q16187 | IsNumber | train | func (p *DefaultWordTokenizer) IsNumber(t *Token) bool {
return strings.HasPrefix(t.Tok, "##number##")
} | go | {
"resource": ""
} |
q16188 | IsInitial | train | func (p *DefaultWordTokenizer) IsInitial(t *Token) bool {
return t.reInitial.MatchString(t.Tok)
} | go | {
"resource": ""
} |
q16189 | IsAlpha | train | func (p *DefaultWordTokenizer) IsAlpha(t *Token) bool {
return t.reAlpha.MatchString(t.Tok)
} | go | {
"resource": ""
} |
q16190 | IsNonPunct | train | func (p *DefaultWordTokenizer) IsNonPunct(t *Token) bool {
nonPunct := regexp.MustCompile(p.PunctStrings.NonPunct())
return nonPunct.MatchString(p.Type(t))
} | go | {
"resource": ""
} |
q16191 | HasPeriodFinal | train | func (p *DefaultWordTokenizer) HasPeriodFinal(t *Token) bool {
return strings.HasSuffix(t.Tok, ".")
} | go | {
"resource": ""
} |
q16192 | HasSentEndChars | train | func (p *DefaultWordTokenizer) HasSentEndChars(t *Token) bool {
enders := []string{
`."`, `.'`, `.)`,
`?`, `?"`, `?'`, `?)`,
`!`, `!"`, `!'`, `!)`, `!’`, `!”`,
}
for _, ender := range enders {
if strings.HasSuffix(t.Tok, ender) {
return true
}
}
parens := []string{
`.[`, `.(`, `."`, `.'`,
`?[`, ... | go | {
"resource": ""
} |
q16193 | Has | train | func (ss SetString) Has(str string) bool {
if ss[str] == 0 {
return false
}
return true
} | go | {
"resource": ""
} |
q16194 | Array | train | func (ss SetString) Array() []string {
arr := make([]string, 0, len(ss))
for key := range ss {
arr = append(arr, key)
}
return arr
} | go | {
"resource": ""
} |
q16195 | addOrthoContext | train | func (p *Storage) addOrthoContext(typ string, flag int) {
p.OrthoContext[typ] |= flag
} | go | {
"resource": ""
} |
q16196 | IsAbbr | train | func (p *Storage) IsAbbr(tokens ...string) bool {
for _, token := range tokens {
if p.AbbrevTypes.Has(token) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q16197 | Add | train | func (ix *Indexes) Add(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: false})
} | go | {
"resource": ""
} |
q16198 | AddUnique | train | func (ix *Indexes) AddUnique(columns ...string) {
name := strings.Join(columns, "_")
*ix = append(*ix, &index{name: name, columns: columns, unique: true})
} | go | {
"resource": ""
} |
q16199 | CreateTableIfNotExists | train | func (mg *Migration) CreateTableIfNotExists(structPtr interface{}) error {
model := structPtrToModel(structPtr, true, nil)
sql := mg.dialect.createTableSql(model, true)
if mg.Log {
fmt.Println(sql)
}
sqls := strings.Split(sql, ";")
for _, v := range sqls {
_, err := mg.db.Exec(v)
if err != nil && !mg.dialec... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.