PathFacetHandler.java

package com.browseengine.bobo.facets.impl;

import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
import it.unimi.dsi.fastutil.ints.IntSet;

import java.io.IOException;
import java.util.List;
import java.util.Properties;

import com.browseengine.bobo.api.BoboSegmentReader;
import com.browseengine.bobo.api.BrowseSelection;
import com.browseengine.bobo.api.FacetSpec;
import com.browseengine.bobo.facets.FacetCountCollector;
import com.browseengine.bobo.facets.FacetCountCollectorSource;
import com.browseengine.bobo.facets.FacetHandler;
import com.browseengine.bobo.facets.data.FacetDataCache;
import com.browseengine.bobo.facets.data.MultiValueFacetDataCache;
import com.browseengine.bobo.facets.data.TermListFactory;
import com.browseengine.bobo.facets.filter.EmptyFilter;
import com.browseengine.bobo.facets.filter.FacetOrFilter;
import com.browseengine.bobo.facets.filter.FacetValueConverter;
import com.browseengine.bobo.facets.filter.MultiValueORFacetFilter;
import com.browseengine.bobo.facets.filter.RandomAccessFilter;
import com.browseengine.bobo.facets.filter.RandomAccessNotFilter;
import com.browseengine.bobo.sort.DocComparatorSource;

public class PathFacetHandler extends FacetHandler<FacetDataCache<?>> {
  private static final String DEFAULT_SEP = "/";

  public static final String SEL_PROP_NAME_STRICT = "strict";
  public static final String SEL_PROP_NAME_DEPTH = "depth";

  private final boolean _multiValue;

  @SuppressWarnings("rawtypes")
  private final TermListFactory _termListFactory;
  private String _separator;
  private final String _indexedName;

  public PathFacetHandler(String name) {
    this(name, false);
  }

  public PathFacetHandler(String name, boolean multiValue) {
    this(name, name, multiValue);
  }

  public PathFacetHandler(String name, String indexedName, boolean multiValue) {
    super(name);
    _indexedName = indexedName;
    _multiValue = multiValue;
    _termListFactory = TermListFactory.StringListFactory;
    _separator = DEFAULT_SEP;
  }

  /**
     * Sets is strict applied for counting. Used if the field is of type <b><i>path</i></b>.
     * @param strict is strict applied
     */
  public static void setStrict(Properties props, boolean strict) {
    props.setProperty(PathFacetHandler.SEL_PROP_NAME_STRICT, String.valueOf(strict));
  }

  /**
   * Sets the depth.  Used if the field is of type <b><i>path</i></b>.
   * @param depth depth
   */
  public static void setDepth(Properties props, int depth) {
    props.setProperty(PathFacetHandler.SEL_PROP_NAME_DEPTH, String.valueOf(depth));
  }

  /**
     * Gets if strict applied for counting. Used if the field is of type <b><i>path</i></b>.
     * @return is strict applied
     */
  public static boolean isStrict(Properties selectionProp) {
    try {
      return Boolean.valueOf(selectionProp.getProperty(PathFacetHandler.SEL_PROP_NAME_STRICT));
    } catch (Exception e) {
      return false;
    }
  }

  @Override
  public int getNumItems(BoboSegmentReader reader, int id) {
    FacetDataCache<?> data = getFacetData(reader);
    if (data == null) return 0;
    return data.getNumItems(id);
  }

  /**
   * Gets the depth.  Used if the field is of type <b><i>path</i></b>.
   * @return depth
   */
  public static int getDepth(Properties selectionProp) {
    try {
      return Integer.parseInt(selectionProp.getProperty(PathFacetHandler.SEL_PROP_NAME_DEPTH));
    } catch (Exception e) {
      return 1;
    }
  }

  @Override
  public DocComparatorSource getDocComparatorSource() {
    return new FacetDataCache.FacetDocComparatorSource(this);
  }

  @Override
  public String[] getFieldValues(BoboSegmentReader reader, int id) {
    FacetDataCache<?> dataCache = getFacetData(reader);
    if (dataCache == null) return new String[0];
    if (_multiValue) {
      return ((MultiValueFacetDataCache<?>) dataCache)._nestedArray.getTranslatedData(id,
        dataCache.valArray);
    } else {
      return new String[] { dataCache.valArray.get(dataCache.orderArray.get(id)) };
    }
  }

  @Override
  public Object[] getRawFieldValues(BoboSegmentReader reader, int id) {
    return getFieldValues(reader, id);
  }

  public void setSeparator(String separator) {
    _separator = separator;
  }

  public String getSeparator() {
    return _separator;
  }

  private static int getPathDepth(String path, String separator) {
    return path.split(String.valueOf(separator)).length;
  }

  private static class PathValueConverter implements FacetValueConverter {
    private final boolean _strict;
    private final String _sep;
    private final int _depth;

    PathValueConverter(int depth, boolean strict, String sep) {
      _strict = strict;
      _sep = sep;
      _depth = depth;
    }

    private void getFilters(FacetDataCache<?> dataCache, IntSet intSet, String[] vals, int depth,
        boolean strict) {
      for (String val : vals) {
        getFilters(dataCache, intSet, val, depth, strict);
      }
    }

    private void getFilters(FacetDataCache<?> dataCache, IntSet intSet, String val, int depth,
        boolean strict) {
      List<String> termList = dataCache.valArray;
      int index = termList.indexOf(val);

      int startDepth = getPathDepth(val, _sep);

      if (index < 0) {
        int nextIndex = -(index + 1);
        if (nextIndex == termList.size()) {
          return;
        }
        index = nextIndex;
      }

      for (int i = index; i < termList.size(); ++i) {
        String path = termList.get(i);
        if (path.startsWith(val)) {
          if (!strict || getPathDepth(path, _sep) - startDepth == depth) {
            intSet.add(i);
          }
        } else {
          break;
        }
      }
    }

    @Override
    public int[] convert(FacetDataCache<String> dataCache, String[] vals) {
      IntSet intSet = new IntOpenHashSet();
      getFilters(dataCache, intSet, vals, _depth, _strict);
      return intSet.toIntArray();
    }

  }

  @Override
  public RandomAccessFilter buildRandomAccessFilter(String value, Properties props)
      throws IOException {
    int depth = getDepth(props);
    boolean strict = isStrict(props);
    PathValueConverter valConverter = new PathValueConverter(depth, strict, _separator);
    String[] vals = new String[] { value };

    return _multiValue ? new MultiValueORFacetFilter(this, vals, valConverter, false)
        : new FacetOrFilter(this, vals, false, valConverter);
  }

  @Override
  public RandomAccessFilter buildRandomAccessAndFilter(String[] vals, Properties prop)
      throws IOException {
    if (vals.length > 1) {
      return EmptyFilter.getInstance();
    } else {
      RandomAccessFilter f = buildRandomAccessFilter(vals[0], prop);
      if (f != null) {
        return f;
      } else {
        return EmptyFilter.getInstance();
      }
    }
  }

  @Override
  public RandomAccessFilter buildRandomAccessOrFilter(String[] vals, Properties prop, boolean isNot)
      throws IOException {
    if (vals.length > 1) {

      if (vals.length > 0) {
        int depth = getDepth(prop);
        boolean strict = isStrict(prop);
        PathValueConverter valConverter = new PathValueConverter(depth, strict, _separator);
        return _multiValue ? new MultiValueORFacetFilter(this, vals, valConverter, isNot)
            : new FacetOrFilter(this, vals, isNot, valConverter);
      } else {
        if (isNot) {
          return null;
        } else {
          return EmptyFilter.getInstance();
        }
      }
    } else {
      RandomAccessFilter f = buildRandomAccessFilter(vals[0], prop);
      if (f == null) return f;
      if (isNot) {
        f = new RandomAccessNotFilter(f);
      }
      return f;
    }
  }

  @Override
  public FacetCountCollectorSource getFacetCountCollectorSource(final BrowseSelection sel,
      final FacetSpec ospec) {
    return new FacetCountCollectorSource() {

      @Override
      public FacetCountCollector getFacetCountCollector(BoboSegmentReader reader, int docBase) {
        FacetDataCache<?> dataCache = PathFacetHandler.this.getFacetData(reader);
        if (_multiValue) {
          return new MultiValuedPathFacetCountCollector(_name, _separator, sel, ospec, dataCache);
        } else {
          return new PathFacetCountCollector(_name, _separator, sel, ospec, dataCache);
        }
      }
    };
  }

  @SuppressWarnings({ "unchecked", "rawtypes" })
  @Override
  public FacetDataCache<?> load(BoboSegmentReader reader) throws IOException {
    if (!_multiValue) {
      FacetDataCache<?> dataCache = new FacetDataCache();
      dataCache.load(_indexedName, reader, _termListFactory);
      return dataCache;
    } else {
      MultiValueFacetDataCache<?> dataCache = new MultiValueFacetDataCache();
      dataCache.load(_indexedName, reader, _termListFactory);
      return dataCache;
    }
  }
}