// AllFields gets the fields to encode for the struct
973828
func (p Path) AllFields() []interface{} {
	nodes := make([]interface{}, len(p.Nodes))
	for i, node := range p.Nodes {
		nodes[i] = node
	}
	relationships := make([]interface{}, len(p.Relationships))
	for i, relationship := range p.Relationships {
		relationships[i] = relationship
	}
	sequences := make([]interface{}, len(p.Sequence))
	for i, sequence := range p.Sequence {
		sequences[i] = sequence
	}
	return []interface{}{nodes, relationships, sequences}
}
357586
func (item *MoreLikeThisQueryItem) Fields(fields ...string) *MoreLikeThisQueryItem {
	item.fields = append(item.fields, fields...)
	return item
}
1210299
func (s *TermvectorsService) Fields(fields ...string) *TermvectorsService {
	if s.fields == nil {
		s.fields = make([]string, 0)
	}
	s.fields = append(s.fields, fields...)
	return s
}
130553
func (s *Scrubber) fields(rv reflect.Value, path Path, callbacks map[string]Path) {
	for i := 0; i < rv.NumField(); i++ {
		sf := rv.Type().Field(i)
		if sf.PkgPath != "" && !sf.Anonymous { // unexported.
			continue
		}

		// dnode uses JSON package tags for field naming so we need to
		// discard their comma-separated options.
		tag := sf.Tag.Get("json")
		if idx := strings.Index(tag, ","); idx != -1 {
			tag = tag[:idx]
		}
		if tag == "-" {
			continue
		}
		// do not collect callbacks for "-" tagged fields.
		if skip := sf.Tag.Get("dnode"); skip == "-" {
			continue
		}

		var name = tag
		if name == "" {
			name = sf.Name
		}

		if sf.Anonymous {
			s.collect(rv.Field(i), path, callbacks)
		} else {
			s.collect(rv.Field(i), append(path, name), callbacks)
		}
	}
}
260781
func (t *tags) All(ctx context.Context) ([]string, error) {
	var tags []string

	listURLStr, err := t.ub.BuildTagsURL(t.name)
	if err != nil {
		return tags, err
	}

	listURL, err := url.Parse(listURLStr)
	if err != nil {
		return tags, err
	}

	for {
		resp, err := t.client.Get(listURL.String())
		if err != nil {
			return tags, err
		}
		defer resp.Body.Close()

		if SuccessStatus(resp.StatusCode) {
			b, err := ioutil.ReadAll(resp.Body)
			if err != nil {
				return tags, err
			}

			tagsResponse := struct {
				Tags []string `json:"tags"`
			}{}
			if err := json.Unmarshal(b, &tagsResponse); err != nil {
				return tags, err
			}
			tags = append(tags, tagsResponse.Tags...)
			if link := resp.Header.Get("Link"); link != "" {
				linkURLStr := strings.Trim(strings.Split(link, ";")[0], "<>")
				linkURL, err := url.Parse(linkURLStr)
				if err != nil {
					return tags, err
				}

				listURL = listURL.ResolveReference(linkURL)
			} else {
				return tags, nil
			}
		} else {
			return tags, HandleErrorResponse(resp)
		}
	}
}
552631
func NewFields(v map[string]interface{}) Fields {
	fields := make(Fields)
	for k, v := range v {
		fields[k] = v
	}
	return fields
}
1222294
func (s *JobManifestSpec) SetFields(v []*string) *JobManifestSpec {
	s.Fields = v
	return s
}
789656
func (i *Index) Fields() []*Field {
	i.mu.RLock()
	defer i.mu.RUnlock()

	a := make([]*Field, 0, len(i.fields))
	for _, f := range i.fields {
		a = append(a, f)
	}
	sort.Sort(fieldSlice(a))

	return a
}
1093196
func AddFields(ctx context.Context, fields logrus.Fields) {
	ctxlogrus.AddFields(ctx, fields)
}
600078
func (s *FieldCapsService) Fields(fields ...string) *FieldCapsService {
	s.fields = append(s.fields, fields...)
	return s
}
189840
func All(validators ...schema.SchemaValidateFunc) schema.SchemaValidateFunc {
	return func(i interface{}, k string) ([]string, []error) {
		var allErrors []error
		var allWarnings []string
		for _, validator := range validators {
			validatorWarnings, validatorErrors := validator(i, k)
			allWarnings = append(allWarnings, validatorWarnings...)
			allErrors = append(allErrors, validatorErrors...)
		}
		return allWarnings, allErrors
	}
}
4777
func (s *stringSet) All() []string {
	all := []string{}
	for v := range s.values {
		all = append(all, v)
	}
	return all
}
755378
func (s *DNSControllerScope) AllKeys() []string {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	var keys []string
	for k := range s.Records {
		keys = append(keys, k)
	}
	return keys
}
936133
func (set LiteralFieldSet) ContainsAll(i ...LiteralField) bool {
	for _, v := range i {
		if !set.Contains(v) {
			return false
		}
	}
	return true
}
713203
func (s *GetDocumentPathInput) SetFields(v string) *GetDocumentPathInput {
	s.Fields = &v
	return s
}
1046912
func (pd *DocumentIterator) All(document Document) (interface{}, error) {
	pd.loadInternal()

	documents := slice(document)
	err := pd.iterator.All(documents)
	if err != nil {
		return nil, err
	}

	return results(documents)
}
390736
func (s *set) All() []interface{} {
	all := []interface{}{}
	for v := range s.values {
		all = append(all, v)
	}
	return all
}