// GetFull indicates that a full document should be retrieved. This command allows you
// to do things like combine with Get to fetch a document with certain Xattrs
165906
func (spec LookupInSpec) GetFull(opts *LookupInSpecGetFullOptions) LookupInOp {
	op := gocbcore.SubDocOp{
		Op:    gocbcore.SubDocOpGetDoc,
		Flags: gocbcore.SubdocFlag(SubdocFlagNone),
	}

	return LookupInOp{op: op}
}
354260
func (d SelectAllBtnDef) getQuery() *search.SearchQuery {
	predicate := d.Props().callbacks.GetQuery()
	if !strings.HasPrefix(predicate, "ref:") {
		return &search.SearchQuery{
			Limit:      -1,
			Expression: predicate,
		}
	}

	// If we've got a ref: predicate, assume the given blobRef is a container, and
	// find its children.
	blobRef := strings.TrimPrefix(predicate, "ref:")
	br, ok := blob.Parse(blobRef)
	if !ok {
		println(`Invalid blobRef in "ref:" predicate: ` + blobRef)
		return nil
	}
	return &search.SearchQuery{
		Limit: -1,
		Constraint: &search.Constraint{Permanode: &search.PermanodeConstraint{
			Relation: &search.RelationConstraint{
				Relation: "parent",
				Any: &search.Constraint{
					BlobRefPrefix: br.String(),
				},
			},
		}},
	}
}
164377
func (cr *Context) GetFillRule() FillRule {
	ret := FillRule(C.cairo_get_fill_rule(cr.Ptr))
	if err := cr.status(); err != nil {
		panic(err)
	}
	return ret
}
659341
func (s *FlushService) Full(full bool) *FlushService {
	s.full = &full
	return s
}
155057
func getLen(x interface{}) (ok bool, length int) {
	v := reflect.ValueOf(x)
	defer func() {
		if e := recover(); e != nil {
			ok = false
		}
	}()
	return true, v.Len()
}
1324643
func (obj *GenericObject) GetFullPropertyTree(ctx context.Context) (*GenericObjectEntry, error) {
	result := &struct {
		PropEntry *GenericObjectEntry	`json:"qPropEntry"`
	} {}
	err := obj.rpc(ctx, "GetFullPropertyTree", result)
	return result.PropEntry, err 
}
1338778
func (r *GormSearchRepository) SearchFullText(ctx context.Context, rawSearchString string, start *int, limit *int, spaceID *string) ([]workitem.WorkItem, int, error) {
	// parse
	// generateSearchQuery
	// ....
	parsedSearchDict, err := parseSearchString(ctx, rawSearchString)
	if err != nil {
		return nil, 0, errs.WithStack(err)
	}

	sqlSearchQueryParameter := generateSQLSearchInfo(parsedSearchDict)
	var rows []workitem.WorkItemStorage
	log.Debug(ctx, map[string]interface{}{"search query": sqlSearchQueryParameter}, "searching for work items")
	rows, count, err := r.search(ctx, sqlSearchQueryParameter, parsedSearchDict.workItemTypes, start, limit, spaceID)
	if err != nil {
		return nil, 0, errs.WithStack(err)
	}
	result := make([]workitem.WorkItem, len(rows))

	for index, value := range rows {
		var err error
		// FIXME: Against best practice http://go-database-sql.org/retrieving.html
		wiType, err := r.witr.Load(ctx, value.Type)
		if err != nil {
			log.Error(ctx, map[string]interface{}{
				"err": err,
				"wit": value.Type,
			}, "failed to load work item type")
			spew.Dump(value)
			return nil, 0, errors.NewInternalError(ctx, errs.Wrap(err, "failed to load work item type"))
		}
		wiModel, err := workitem.ConvertWorkItemStorageToModel(wiType, &value)
		if err != nil {
			return nil, 0, errors.NewConversionError(err.Error())
		}
		result[index] = *wiModel
	}

	return result, count, nil
}
124422
func (p *PullRequestLinks) GetURL() string {
	if p == nil || p.URL == nil {
		return ""
	}
	return *p.URL
}
1306321
func (doc *Document) GetDocument() ([]byte, error) {
	if doc.Id != "" {
		return doc.getDocFromId()
	}

	return nil, errors.New("An id required to search for the document.")
}
1242407
func (d *driver) getFullName(name string) string {
	if d.tag() != "" {
		return d.tag() + azureud.TagDelimiter + name
	}
	return name
}
1230062
func (m *NodeManager) GetFullTree() ([]byte, error) {
	m.mu.Lock()
	defer m.mu.Unlock()
	return m.toJSON(0)
}
1085141
func (fs *Goofys) GetFullName(id fuseops.InodeID) *string {
	fs.mu.Lock()
	inode := fs.inodes[id]
	fs.mu.Unlock()
	if inode == nil {
		return nil
	}
	return inode.FullName()

}
1281709
func (b Base) GetURL(option *Option, scope *gorm.Scope, field *gorm.Field, templater URLTemplater) string {
	if path := templater.GetURLTemplate(option); path != "" {
		tmpl := template.New("").Funcs(getFuncMap(scope, field, b.GetFileName()))
		if tmpl, err := tmpl.Parse(path); err == nil {
			var result = bytes.NewBufferString("")
			if err := tmpl.Execute(result, scope.Value); err == nil {
				return result.String()
			}
		}
	}
	return ""
}
1034805
func (v Uint64) Get(deflt uint64) uint64 {
	if !v.Defined {
		return deflt
	}
	return v.V
}
746958
func (rt *requireTree) GetList(extInfo *types.ExtensionInfo) (requiredFiles []string, lastModified int64, err error) {
	finalPath := rt.Path
	if !filepath.IsAbs(finalPath) {
		finalPath = filepath.Join(rt.BaseDir, rt.Path)
		if newPath, err := filepath.EvalSymlinks(finalPath); err == nil {
			finalPath = newPath
		}
	}
	alterExts := extInfo.AlterExts
	if alterExts.Len() == 0 {
		return nil, 0, errors.New("Extension Format unknown for require:" + extInfo.CurrentExtension)
	}
	err = filepath.Walk(finalPath, func(walkpath string, f os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if modified := f.ModTime().Unix(); lastModified < modified {
			lastModified = modified
		}
		if f.IsDir() {
			return nil
		}
		curExt := filepath.Ext(walkpath)
		if curExt == extInfo.CurrentExtension {
			requiredFiles = append(requiredFiles, walkpath)
			return nil
		}
		for e := alterExts.Front(); e != nil; e = e.Next() {
			if e.Value == curExt {
				requiredFiles = append(requiredFiles, walkpath)
				break
			}
		}
		return nil
	})
	if err != nil {
		return nil, 0, err
	}
	sort.Strings(requiredFiles)
	return
}
510116
func (ctx *ShowBottleContext) OKFull(r *BottleFull) error {
	if ctx.ResponseData.Header().Get("Content-Type") == "" {
		ctx.ResponseData.Header().Set("Content-Type", "application/vnd.bottle+json")
	}
	return ctx.ResponseData.Service.Send(ctx.Context, 200, r)
}
1062326
func (txl *Impl) Get(immediate *querypb.VTGateCallerID, effective *vtrpcpb.CallerID) bool {
	key := txl.extractKey(immediate, effective)

	txl.mu.Lock()
	defer txl.mu.Unlock()

	usage := txl.usageMap[key]
	if usage < txl.maxPerUser {
		txl.usageMap[key] = usage + 1
		return true
	}

	if txl.dryRun {
		log.Infof("TxLimiter: DRY RUN: user over limit: %s", key)
		rejectionsDryRun.Add(key, 1)
		return true
	}

	log.Infof("TxLimiter: Over limit, rejecting transaction request for user: %s", key)
	rejections.Add(key, 1)
	return false
}