// Prints a Field for human consumption.
974019
func (ft *FieldType) String() string {
	var buf bytes.Buffer
	if ft.Stored() {
		buf.WriteString("stored")
	}
	if ft.Indexed() {
		if buf.Len() > 0 {
			buf.WriteString(",")
		}
		buf.WriteString("indexed")
		if ft.Tokenized() {
			buf.WriteString(",tokenized")
		}
		if ft.StoreTermVectors() {
			buf.WriteString(",termVector")
		}
		if ft.StoreTermVectorOffsets() {
			buf.WriteString(",termVectorOffsets")
		}
		if ft.StoreTermVectorPositions() {
			buf.WriteString(",termVectorPosition")
		}
		if ft.StoreTermVectorPayloads() {
			buf.WriteString(",termVectorPayloads")
		}
		if ft.OmitNorms() {
			buf.WriteString(",omitNorms")
		}
		if ft.IndexOptions() != model.INDEX_OPT_DOCS_AND_FREQS_AND_POSITIONS {
			fmt.Fprintf(&buf, ",indexOptions=%v", ft.IndexOptions())
		}
		if ft.numericType != 0 {
			fmt.Fprintf(&buf, ",numericType=%v,numericPrecisionStep=%v", ft.numericType, ft.numericPrecisionStep)
		}
	}
	if ft.DocValueType() != 0 {
		if buf.Len() > 0 {
			buf.WriteString(",")
		}
		fmt.Fprintf(&buf, "docValueType=%v", ft.DocValueType())
	}
	return buf.String()
}
1198762
func (q *PrefixQuery) Field(field string) *PrefixQuery {
	q.options["field"] = field
	return q
}
1273900
func print(w io.Writer, v interface{}) {
	if s, ok := v.(fmt.Stringer); ok {
		fmt.Fprint(w, s.String())
	} else {
		switch v.(type) {
		case string:
			fmt.Fprintf(w, "%s", v)
		case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
			fmt.Fprintf(w, "%d", v)
		case float32, float64:
			fmt.Fprintf(w, "%g", v)
		default:
			fmt.Fprintf(w, "%v", v)
		}
	}
}
283025
func Print(v ...interface{}) {
	std.Fprint(std.flags, LEVEL_PRINT, 2, fmt.Sprint(v...), nil)
}
859046
func print(v interface{}) string {
	switch vt := v.(type) {
	case Map:
		return vt.String()
	case Slice:
		return vt.String()
	case BSON:
		return fmt.Sprintf("BSON(%v)", vt)
	case Float:
		return fmt.Sprintf("Float(%v)", vt)
	case String:
		return fmt.Sprintf("String(%v)", vt)
	case Array:
		wr := bytes.NewBuffer(nil)
		fmt.Fprint(wr, "Array([")
		for i, vtv := range vt {
			fmt.Fprint(wr, print(vtv))
			if i != len(vt)-1 {
				fmt.Fprint(wr, " ")
			}
		}
		fmt.Fprintf(wr, "])")
		return wr.String()
	case Binary:
		return fmt.Sprintf("Binary(%v)", vt)
	case Undefined:
		return "Undefined()"
	case ObjectId:
		return fmt.Sprintf("ObjectId(%v)", vt)
	case Bool:
		return fmt.Sprintf("Bool(%v)", vt)
	case UTCDateTime:
		return fmt.Sprintf("UTCDateTime(%v)", time.Unix(0, int64(vt)*1000*1000))
	case Null:
		return "Null()"
	case Regexp:
		return fmt.Sprintf("Regexp(Pattern(%v) Options(%v))", vt.Pattern, vt.Options)
	case DBPointer:
		return fmt.Sprintf("DBPointer(Name(%v) ObjectId(%v))", vt.Name, vt.ObjectId)
	case Javascript:
		return fmt.Sprintf("Javascript(%v)", vt)
	case Symbol:
		return fmt.Sprintf("Symbol(%v)", vt)
	case JavascriptScope:
		return fmt.Sprintf("JavascriptScope(Javascript(%v) Scope(%v))", vt.Javascript, vt.Scope)
	case Int32:
		return fmt.Sprintf("Int32(%v)", vt)
	case Timestamp:
		return fmt.Sprintf("Timestamp(%v)", vt)
	case Int64:
		return fmt.Sprintf("Int64(%v)", vt)
	case MinKey:
		return "MinKey()"
	case MaxKey:
		return "MaxKey()"
	}
	return fmt.Sprint(v)
}
68854
func (v *ResultErrorFields) Field() string {
	return strings.TrimPrefix(v.context.String(), STRING_ROOT_SCHEMA_PROPERTY+".")
}
601444
func (s *state) printValue(n parse.Node, v reflect.Value) {
	s.at(n)
	iface, ok := printableValue(v)
	if !ok {
		s.errorf("can't print %s of type %s", n, v.Type())
	}
	fmt.Fprint(s.wr, iface)
}
880821
func (h *Holder) Field(index, name string) *Field {
	idx := h.Index(index)
	if idx == nil {
		return nil
	}
	return idx.Field(name)
}
494320
func (l *FastHTTPLoggerAdapter) Printf(msg string, v ...interface{}) {
	l.apexLogger.Debugf(msg, v...)
}
16065
func (q *MoreLikeThisQuery) Field(fields ...string) *MoreLikeThisQuery {
	q.fields = append(q.fields, fields...)
	return q
}
889857
func (fn FieldValueFactorFunction) Field(field string) FieldValueFactorFunction {
	fn.field = field
	return fn
}
443700
func (db *MemDB) Print() {
	db.mtx.Lock()
	defer db.mtx.Unlock()

	for key, value := range db.db {
		fmt.Printf("[%X]:\t[%X]\n", []byte(key), value)
	}
}
397736
func (p FmtPrinter) Print(logger *Logger, a ...interface{}) {
	b := make([]interface{}, 1)
	b[0] = logger.Color(logger.Name)
	a = append(b, a...)
	fmt.Fprint(os.Stderr, a...)
}
61066
func (schema DatabaseSchema) Print(w io.Writer) {
	fmt.Fprintf(w, "%s, (%s)\n", schema.Name, schema.Version)
	for table, tableSchema := range schema.Tables {
		fmt.Fprintf(w, "\t %s\n", table)
		for column, columnSchema := range tableSchema.Columns {
			fmt.Fprintf(w, "\t\t %s => %v\n", column, columnSchema)
		}
	}
}
1368156
func (s *IndicesAnalyzeService) Field(field string) *IndicesAnalyzeService {
	s.request.Field = field
	return s
}
1006748
func (q *WildcardQuery) Field(field string) *WildcardQuery {
	q.options["field"] = field
	return q
}
5242
func Print() {
	payload, err := json.Marshal(Get())
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s", payload)
}