LukeResponse.java example

Explorer
lucene-solr-master
- lucene
- solr
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.solr.client.solrj.response;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.solr.common.luke.FieldFlag;
import org.apache.solr.common.util.NamedList;


/**
 * This is an incomplete representation of the data returned from Luke
 *
 *
 * @since solr 1.3
 */
public class LukeResponse extends SolrResponseBase {

  public static class FieldTypeInfo implements Serializable {
    String name;
    String className;
    boolean tokenized;
    String analyzer;
    List<String> fields;
    List<String> dynamicFields;


    public FieldTypeInfo(String name) {
      this.name = name;
      fields = Collections.emptyList();
    }


    public String getAnalyzer() {
      return analyzer;
    }

    public String getClassName() {
      return className;
    }

    public List<String> getFields() {
      return fields;
    }

    public List<String> getDynamicFields() {
      return dynamicFields;
    }

    public String getName() {
      return name;
    }

    public boolean isTokenized() {
      return tokenized;
    }/*
     Sample:
     types={ignored={fields=null,tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@f94934},
     integer={fields=null,tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@3525a2},
     sfloat={fields=[price, weight],tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@39cf9c},
     text_ws={fields=[cat],tokenized=true,analyzer=TokenizerChain(org.apache.solr.analysis.WhitespaceTokenizerFactory@6d3ca2)},
     alphaOnlySort={fields=[alphaNameSort],tokenized=true,analyzer=TokenizerChain(org.apache.solr.analysis.KeywordTokenizerFactory@a7bd3b,
      org.apache.solr.analysis.LowerCaseFilterFactory@78aae2, org.apache.solr.analysis.TrimFilterFactory@1b16a7,
      org.apache.solr.analysis.PatternReplaceFilterFactory@6c6b08)},date={fields=[timestamp],tokenized=false,
      analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@e6e42e},sint={fields=[popularity],
      tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@8ea21d},
      boolean={fields=[inStock],tokenized=false,analyzer=org.apache.solr.schema.BoolField$1@354949},
      textTight={fields=[sku],tokenized=true,analyzer=TokenizerChain(org.apache.solr.analysis.WhitespaceTokenizerFactory@5e88f7,
       org.apache.solr.analysis.SynonymFilterFactory@723646, org.apache.solr.analysis.StopFilterFactory@492ff1,
       org.apache.solr.analysis.WordDelimiterFilterFactory@eaabad, org.apache.solr.analysis.LowerCaseFilterFactory@ad1355,
        org.apache.solr.analysis.EnglishPorterFilterFactory@d03a00, org.apache.solr.analysis.RemoveDuplicatesTokenFilterFactory@900079)},
        long={fields=null,tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@f3b83},
        double={fields=null,tokenized=false,analyzer=org.apache.solr.schema.FieldType$DefaultAnalyzer@c2b07},

      */

    @SuppressWarnings("unchecked")
    public void read(NamedList<Object> nl) {
      for (Map.Entry<String, Object> entry : nl) {
        String key = entry.getKey();
        if ("fields".equals(key) && entry.getValue() != null) {
          List<String> theFields = (List<String>) entry.getValue();
          fields = new ArrayList<>(theFields);
        } else if ("dynamicFields".equals(key) && entry.getValue() != null) {
          List<String> theDynamicFields = (List<String>) entry.getValue();
          dynamicFields = new ArrayList<>(theDynamicFields);
        } else if ("tokenized".equals(key) == true) {
          tokenized = Boolean.parseBoolean(entry.getValue().toString());
        } else if ("analyzer".equals(key) == true) {
          analyzer = entry.getValue().toString();
        } else if ("className".equals(key) == true) {
          className = entry.getValue().toString();
        }
      }
    }
  }

  public static class FieldInfo implements Serializable {
    String name;
    String type;
    String schema;
    int docs;
    int distinct;
    EnumSet<FieldFlag> flags;
    boolean cacheableFaceting;
    NamedList<Integer> topTerms;

    public FieldInfo(String n) {
      name = n;
    }

    @SuppressWarnings("unchecked")
    public void read(NamedList<Object> nl) {
      for (Map.Entry<String, Object> entry : nl) {
        if ("type".equals(entry.getKey())) {
          type = (String) entry.getValue();
        }
        if ("flags".equals(entry.getKey())) {
          flags = parseFlags((String) entry.getValue());
        } else if ("schema".equals(entry.getKey())) {
          schema = (String) entry.getValue();
        } else if ("docs".equals(entry.getKey())) {
          docs = (Integer) entry.getValue();
        } else if ("distinct".equals(entry.getKey())) {
          distinct = (Integer) entry.getValue();
        } else if ("cacheableFaceting".equals(entry.getKey())) {
          cacheableFaceting = (Boolean) entry.getValue();
        } else if ("topTerms".equals(entry.getKey())) {
          topTerms = (NamedList<Integer>) entry.getValue();
        }
      }
    }

    public static EnumSet<FieldFlag> parseFlags(String flagStr) {
      EnumSet<FieldFlag> result = EnumSet.noneOf(FieldFlag.class);
      char[] chars = flagStr.toCharArray();
      for (int i = 0; i < chars.length; i++) {
        if (chars[i] != '-') {
          FieldFlag flag = FieldFlag.getFlag(chars[i]);
          result.add(flag);
        }
      }
      return result;
    }

    public EnumSet<FieldFlag> getFlags() {
      return flags;
    }

    public boolean isCacheableFaceting() {
      return cacheableFaceting;
    }

    public String getType() {
      return type;
    }

    public int getDistinct() {
      return distinct;
    }

    public int getDocs() {
      return docs;
    }

    public String getName() {
      return name;
    }

    public String getSchema() {
      return schema;
    }

    public EnumSet<FieldFlag> getSchemaFlags() {
      return flags;
    }

    public NamedList<Integer> getTopTerms() {
      return topTerms;
    }
  }

  private NamedList<Object> indexInfo;
  private Map<String, FieldInfo> fieldInfo;
  private Map<String, FieldInfo> dynamicFieldInfo;
  private Map<String, FieldTypeInfo> fieldTypeInfo;

  @Override
  @SuppressWarnings("unchecked")
  public void setResponse(NamedList<Object> res) {
    super.setResponse(res);

    // Parse indexinfo
    indexInfo = (NamedList<Object>) res.get("index");

    NamedList<Object> schema = (NamedList<Object>) res.get("schema");
    NamedList<Object> flds = (NamedList<Object>) res.get("fields");
    NamedList<Object> dynamicFlds = (NamedList<Object>) res.get("dynamicFields");

    if (flds == null && schema != null ) {
      flds = (NamedList<Object>) schema.get("fields");
    }
    if (flds != null) {
      fieldInfo = new HashMap<>();
      for (Map.Entry<String, Object> field : flds) {
        FieldInfo f = new FieldInfo(field.getKey());
        f.read((NamedList<Object>) field.getValue());
        fieldInfo.put(field.getKey(), f);
      }
    }

    if (dynamicFlds == null && schema != null) {
      dynamicFlds = (NamedList<Object>) schema.get("dynamicFields");
    }
    if (dynamicFlds != null) {
      dynamicFieldInfo = new HashMap<>();
      for (Map.Entry<String, Object> dynamicField : dynamicFlds) {
        FieldInfo f = new FieldInfo(dynamicField.getKey());
        f.read((NamedList<Object>) dynamicField.getValue());
        dynamicFieldInfo.put(dynamicField.getKey(), f);
      }
    }

    if( schema != null ) {
      NamedList<Object> fldTypes = (NamedList<Object>) schema.get("types");
      if (fldTypes != null) {
        fieldTypeInfo = new HashMap<>();
        for (Map.Entry<String, Object> fieldType : fldTypes) {
          FieldTypeInfo ft = new FieldTypeInfo(fieldType.getKey());
          ft.read((NamedList<Object>) fieldType.getValue());
          fieldTypeInfo.put(fieldType.getKey(), ft);
        }
      }
    }
  }

  //----------------------------------------------------------------
  //----------------------------------------------------------------

  public String getIndexDirectory() {
    if (indexInfo == null) return null;
    return (String) indexInfo.get("directory");
  }

  public Integer getNumDocs() {
    if (indexInfo == null) return null;
    return (Integer) indexInfo.get("numDocs");
  }

  public Integer getMaxDoc() {
    if (indexInfo == null) return null;
    return (Integer) indexInfo.get("maxDoc");
  }

  public Integer getNumTerms() {
    if (indexInfo == null) return null;
    return (Integer) indexInfo.get("numTerms");
  }

  public Map<String, FieldTypeInfo> getFieldTypeInfo() {
    return fieldTypeInfo;
  }

  public FieldTypeInfo getFieldTypeInfo(String name) {
    return fieldTypeInfo.get(name);
  }

  public NamedList<Object> getIndexInfo() {
    return indexInfo;
  }

  public Map<String, FieldInfo> getFieldInfo() {
    return fieldInfo;
  }

  public FieldInfo getFieldInfo(String f) {
    return fieldInfo.get(f);
  }

  public Map<String, FieldInfo> getDynamicFieldInfo() {
    return dynamicFieldInfo;
  }

  public FieldInfo getDynamicFieldInfo(String f) {
    return dynamicFieldInfo.get(f);
  }

  //----------------------------------------------------------------
}