core/org.eclipse.smila.solr/code/src/org/eclipse/smila/solr/search/FieldValueTypeCache.java

/**
 *
 */
package org.eclipse.smila.solr.search;

import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang.ArrayUtils;
import org.eclipse.smila.datamodel.Any.ValueType;
import org.eclipse.smila.datamodel.Record;
import org.eclipse.smila.datamodel.util.MetadataUtils;
import org.eclipse.smila.datamodel.util.MetadataUtils.Mode;
import org.eclipse.smila.solr.SolrSchemaService;
import org.eclipse.smila.solr.SolrServiceException;
import org.eclipse.smila.solr.params.KeyValueParam;

import com.google.common.base.Splitter;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

/**
 * @author pwissel
 *
 */
public class FieldValueTypeCache {

  private static final long EXPIRE_AFTER_MINUTES_DEFAULT = 60;

  final SolrSchemaService _schemaService;

  LoadingCache<String, ValueType> _cache = null;

  final Splitter _splitter = Splitter.on("/");

  public FieldValueTypeCache(final SolrSchemaService schemaService) {
    this(schemaService, EXPIRE_AFTER_MINUTES_DEFAULT);
  }

  public FieldValueTypeCache(final SolrSchemaService schemaService, Long exprireAfterMinutes) {
    _schemaService = schemaService;
    exprireAfterMinutes = exprireAfterMinutes != null ? exprireAfterMinutes : EXPIRE_AFTER_MINUTES_DEFAULT;
    // builder cache
    _cache =
      CacheBuilder.newBuilder().expireAfterWrite(exprireAfterMinutes, TimeUnit.MINUTES)
        .build(new CacheLoader<String, ValueType>() {

          @Override
          public ValueType load(final String key) throws Exception {
            return newValueType(key);
          }

        });
  }

  private ValueType newValueType(final String key) throws SolrServiceException {
    final List<String> split = _splitter.splitToList(key);
    final String type = getTypeFromSchema(split.get(0), split.get(1), split.get(2));
    return getTypeAsValueType(type);
  }

  public ValueType get(final String client, final String index, final String field) throws ExecutionException {
    final String key = getKey(client, index, field);
    return _cache.get(key);
  }

  private String getKey(final String client, final String index, final String field) {
    return new StringBuilder("#").append(client).append("/").append(index).append("/").append(field).toString();
  }

  private String getTypeFromSchema(final String client, final String index, final String field)
    throws SolrServiceException {
    final Record fieldInfo =
      _schemaService.getField(client, index, field, new KeyValueParam("includeDynamic", true));
    return MetadataUtils.getValue(fieldInfo.getMetadata(), Mode.FAIL, "fields", "1", "type").asString();
  }

  private static final String[] LONGS = { "int", "short", "long" };

  private static final String[] DOUBLES = { "float", "double" };

  private static final String[] DATES = { "date" };

  private static final String[] BOOLEANS = { "boolean" };

  private ValueType getTypeAsValueType(final String type) {
    if (ArrayUtils.contains(LONGS, type)) {
      return ValueType.LONG;
    } else if (ArrayUtils.contains(DOUBLES, type)) {
      return ValueType.DOUBLE;
    } else if (ArrayUtils.contains(DATES, type)) {
      return ValueType.DATETIME;
    } else if (ArrayUtils.contains(BOOLEANS, type)) {
      return ValueType.BOOLEAN;
    }
    return ValueType.STRING;
  }

}