final Map<String, Object> fields = searchHit.getSourceAsMap();
                    target.setParentUrl(getFieldValue(fields.get("parentUrl"), String.class));
                    target.setMethod(getFieldValue(fields.get("method"), String.class));
                    target.setMimeType(getFieldValue(fields.get("mimeType"), String.class));
                    target.setSessionId(getFieldValue(fields.get("sessionId"), String.class));

     * @param boost the boost value
     * @param readings the list of readings
     * @param fields the list of fields
     * @param tags the list of tags
     * @param roles the list of roles
     */
    public ElevateWord(final String elevateWord, final float boost, final List<String> readings, final List<String> fields,
            final List<String> tags, final List<String> roles) {
        this.elevateWord = elevateWord;

    /**
     * Parses a document and extracts suggest items based on the provided fields and converters.
     *
     * @param document The document to parse, represented as a map of field names to values.
     * @param fields The fields to extract from the document.
     * @param tagFieldNames The names of the fields that contain tags.
     * @param roleFieldName The name of the field that contains role information.

				if idx.Option == "" {
					idx.Option = index.Option
				}

				idx.Fields = append(idx.Fields, index.Fields...)
				sort.Slice(idx.Fields, func(i, j int) bool {
					return idx.Fields[i].Priority < idx.Fields[j].Priority
				})
			}
		}
	}
	for _, index := range indexes {
		if index.Class == "UNIQUE" && len(index.Fields) == 1 {
			index.Fields[0].Field.UniqueIndex = index.Name
		}
	}
	return indexes
}

            <type>Phase</type>
            <multiplicity>*</multiplicity>
          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Phase</name>
      <version>1.0.0+</version>
      <description>A phase mapping definition.</description>
      <fields>
        <field>
          <name>id</name>
          <required>true</required>
          <version>1.0.0+</version>

     * @param id the document ID to retrieve
     * @param fields the fields to include in the response (null for all fields)
     * @return the document as a map of field names to values, or null if not found
     */
    public Map<String, Object> getDocument(final SearchEngineClient searchEngineClient, final String id, final String[] fields) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

     * @param fields array of fields to search in
     * @param excludes array of words to exclude from results
     * @return list of popular words matching the criteria
     */
    public List<String> getWordList(final SearchRequestType searchRequestType, final String seed, final String[] tags, final String[] roles,
            final String[] fields, final String[] excludes) {

	}

	switch reflectValue.Kind() {
	case reflect.Map:
		results = [][]interface{}{make([]interface{}, len(fields))}
		for idx, field := range fields {
			mapValue := reflectValue.MapIndex(reflect.ValueOf(field.DBName))
			if mapValue.IsZero() {
				mapValue = reflectValue.MapIndex(reflect.ValueOf(field.Name))
			}
			results[0][idx] = mapValue.Interface()
		}

 * <li>{@link #QUERY_FREQ} - The query frequency field.</li>
 * <li>{@link #DOC_FREQ} - The document frequency field.</li>
 * <li>{@link #USER_BOOST} - The user boost field.</li>
 * <li>{@link #KINDS} - The kinds field.</li>
 * <li>{@link #TIMESTAMP} - The timestamp field.</li>
 * <li>{@link #TAGS} - The tags field.</li>
 * <li>{@link #ROLES} - The roles field.</li>
 * <li>{@link #FIELDS} - The fields field.</li>

          </association>
        </field>
      </fields>
    </class>
    <class>
      <name>Profile</name>
      <version>1.0.0</version>
      <description><![CDATA[
        Modifications to the build process which is keyed on some
        sort of environmental parameter.
      ]]></description>
      <fields>
        <field>
          <name>id</name>
          <required>true</required>