data := struct {Name stringDes  string}{Name: "hello world this is bone",Des:  "this is a good time",}// index some dataindex.Index("id", data)

index.Index("id", data)

// Index adds the specified index operation to the
// batch.  NOTE: the bleve Index is not updated
// until the batch is executed.
func (b *Batch) Index(id string, data interface{}) error {if id == "" {return ErrorEmptyID}doc := document.NewDocument(id)err := b.index.Mapping().MapDocument(doc, data)if err != nil {return err}b.internal.Update(doc)return nil
}

func (im *IndexMappingImpl) MapDocument(doc *document.Document, data interface{}) error {docType := im.determineType(data)docMapping := im.mappingForType(docType)walkContext := im.newWalkContext(doc, docMapping)if docMapping.Enabled {docMapping.walkDocument(data, []string{}, []uint64{}, walkContext)// see if the _all field was disabledallMapping := docMapping.documentMappingForPath("_all")if allMapping == nil || (allMapping.Enabled != false) {field := document.NewCompositeFieldWithIndexingOptions("_all", true, []string{}, walkContext.excludedFromAll, document.IndexField|document.IncludeTermVectors)doc.AddField(field)}}return nil
} 

func (dm *DocumentMapping) walkDocument(data interface{}, path []string, indexes []uint64, context *walkContext) {// allow default "json" tag to be overridenstructTagKey := dm.StructTagKeyif structTagKey == "" {structTagKey = "json"}val := reflect.ValueOf(data)typ := val.Type()switch typ.Kind() {case reflect.Map:// FIXME can add support for other map keys in the futureif typ.Key().Kind() == reflect.String {for _, key := range val.MapKeys() {fieldName := key.String()fieldVal := val.MapIndex(key).Interface()dm.processProperty(fieldVal, append(path, fieldName), indexes, context)}}case reflect.Struct:for i := 0; i < val.NumField(); i++ {field := typ.Field(i)fieldName := field.Name// anonymous fields of type struct can elide the type nameif field.Anonymous && field.Type.Kind() == reflect.Struct {fieldName = ""}// if the field has a name under the specified tag, prefer thattag := field.Tag.Get(structTagKey)tagFieldName := parseTagName(tag)if tagFieldName == "-" {continue}// allow tag to set field name to empty, only if anonymousif field.Tag != "" && (tagFieldName != "" || field.Anonymous) {fieldName = tagFieldName}if val.Field(i).CanInterface() {fieldVal := val.Field(i).Interface()newpath := pathif fieldName != "" {newpath = append(path, fieldName)}dm.processProperty(fieldVal, newpath, indexes, context)}}case reflect.Slice, reflect.Array:for i := 0; i < val.Len(); i++ {if val.Index(i).CanInterface() {fieldVal := val.Index(i).Interface()dm.processProperty(fieldVal, path, append(indexes, uint64(i)), context)}}case reflect.Ptr:ptrElem := val.Elem()if ptrElem.IsValid() && ptrElem.CanInterface() {dm.processProperty(ptrElem.Interface(), path, indexes, context)}case reflect.String:dm.processProperty(val.String(), path, indexes, context)case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:dm.processProperty(float64(val.Int()), path, indexes, context)case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:dm.processProperty(float64(val.Uint()), path, indexes, context)case reflect.Float32, reflect.Float64:dm.processProperty(float64(val.Float()), path, indexes, context)case reflect.Bool:dm.processProperty(val.Bool(), path, indexes, context)}}

func (dm *DocumentMapping) processProperty(property interface{}, path []string, indexes []uint64, context *walkContext) {pathString := encodePath(path)// look to see if there is a mapping for this fieldsubDocMapping := dm.documentMappingForPath(pathString)closestDocMapping := dm.closestDocMapping(pathString)// check to see if we even need to do further processingif subDocMapping != nil && !subDocMapping.Enabled {return}propertyValue := reflect.ValueOf(property)if !propertyValue.IsValid() {// cannot do anything with the zero valuereturn}propertyType := propertyValue.Type()switch propertyType.Kind() {case reflect.String:propertyValueString := propertyValue.String()if subDocMapping != nil {// index by explicit mappingfor _, fieldMapping := range subDocMapping.Fields {fieldMapping.processString(propertyValueString, pathString, path, indexes, context)}} else if closestDocMapping.Dynamic {// automatic indexing behavior// first see if it can be parsed by the default date parserdateTimeParser := context.im.DateTimeParserNamed(context.im.DefaultDateTimeParser)if dateTimeParser != nil {parsedDateTime, err := dateTimeParser.ParseDateTime(propertyValueString)if err != nil {// index as textfieldMapping := newTextFieldMappingDynamic(context.im)fieldMapping.processString(propertyValueString, pathString, path, indexes, context)} else {// index as datetimefieldMapping := newDateTimeFieldMappingDynamic(context.im)fieldMapping.processTime(parsedDateTime, pathString, path, indexes, context)}}case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:dm.processProperty(float64(propertyValue.Int()), path, indexes, context)returncase reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:dm.processProperty(float64(propertyValue.Uint()), path, indexes, context)returncase reflect.Float64, reflect.Float32:propertyValFloat := propertyValue.Float()if subDocMapping != nil {// index by explicit mappingfor _, fieldMapping := range subDocMapping.Fields {fieldMapping.processFloat64(propertyValFloat, pathString, path, indexes, context)}} else if closestDocMapping.Dynamic {// automatic indexing behaviorfieldMapping := newNumericFieldMappingDynamic(context.im)fieldMapping.processFloat64(propertyValFloat, pathString, path, indexes, context)}case reflect.Bool:propertyValBool := propertyValue.Bool()if subDocMapping != nil {// index by explicit mappingfor _, fieldMapping := range subDocMapping.Fields {fieldMapping.processBoolean(propertyValBool, pathString, path, indexes, context)}} else if closestDocMapping.Dynamic {// automatic indexing behaviorfieldMapping := newBooleanFieldMappingDynamic(context.im)fieldMapping.processBoolean(propertyValBool, pathString, path, indexes, context)}case reflect.Struct:switch property := property.(type) {case time.Time:// don't descend into the time structif subDocMapping != nil {// index by explicit mappingfor _, fieldMapping := range subDocMapping.Fields {fieldMapping.processTime(property, pathString, path, indexes, context)}} else if closestDocMapping.Dynamic {fieldMapping := newDateTimeFieldMappingDynamic(context.im)fieldMapping.processTime(property, pathString, path, indexes, context)}default:dm.walkDocument(property, path, indexes, context)}default:dm.walkDocument(property, path, indexes, context)}
}

func (fm *FieldMapping) processString(propertyValueString string, pathString string, path []string, indexes []uint64, context *walkContext) {fieldName := getFieldName(pathString, path, fm)options := fm.Options()if fm.Type == "text" {     analyzer := fm.analyzerForField(path, context)field := document.NewTextFieldCustom(fieldName, indexes, []byte(propertyValueString), options, analyzer)context.doc.AddField(field)     if !fm.IncludeInAll {  context.excludedFromAll = append(context.excludedFromAll, fieldName)}} else if fm.Type == "datetime" { dateTimeFormat := context.im.DefaultDateTimeParserif fm.DateFormat != "" {        dateTimeFormat = fm.DateFormat  }dateTimeParser := context.im.DateTimeParserNamed(dateTimeFormat)if dateTimeParser != nil {      parsedDateTime, err := dateTimeParser.ParseDateTime(propertyValueString)if err == nil {fm.processTime(parsedDateTime, pathString, path, indexes, context)}                  }}
}func (fm *FieldMapping) processFloat64(propertyValFloat float64, pathString string, path []string, indexes []uint64, context *walkContext) {fieldName := getFieldName(pathString, path, fm)if fm.Type == "number" {options := fm.Options()field := document.NewNumericFieldWithIndexingOptions(fieldName, indexes, propertyValFloat, options)context.doc.AddField(field)if !fm.IncludeInAll {context.excludedFromAll = append(context.excludedFromAll, fieldName)}}
}