com.datatorrent.api.Operator.Unifier Java Examples

@SuppressWarnings("unchecked")
public static Node<?> retrieveNode(Object operator, OperatorContext context, OperatorDeployInfo.OperatorType type)
{
  logger.debug("type={}, operator class={}", type, operator.getClass());

  Node<?> node;
  if (operator instanceof InputOperator && type == OperatorDeployInfo.OperatorType.INPUT) {
    node = new InputNode((InputOperator)operator, context);
  } else if (operator instanceof Unifier && type == OperatorDeployInfo.OperatorType.UNIFIER) {
    node = new UnifierNode((Unifier<Object>)operator, context);
  } else if (type == OperatorDeployInfo.OperatorType.OIO) {
    node = new OiONode((Operator)operator, context);
  } else {
    node = new GenericNode((Operator)operator, context);
  }

  return node;
}
 

public Operator.Unifier<?> getUnifier()
{
  for (Map.Entry<OutputPort<?>, OutputPortMeta> e : operatorMeta.getPortMapping().outPortMap.entrySet()) {
    if (e.getValue() == this) {
      Unifier<?> unifier = e.getKey().getUnifier();
      if (unifier == null) {
        break;
      }
      LOG.debug("User supplied unifier is {}", unifier);
      return unifier;
    }
  }

  LOG.debug("Using default unifier for {}", this);
  return new DefaultUnifier();
}
 

@Override
public Unifier<Long> getUnifier()
{
  UnifierSumNumber<Long> ret = new UnifierSumNumber<Long>();
  ret.setType(Long.class);
  return ret;
}
 

@Override
public Unifier<Integer> getUnifier()
{
  UnifierSumNumber<Integer> ret = new UnifierSumNumber<Integer>();
  ret.setType(Integer.class);
  return ret;
}
 

@Override
public Unifier<Double> getUnifier()
{
  UnifierSumNumber<Double> ret = new UnifierSumNumber<Double>();
  ret.setType(Double.class);
  return ret;
}
 

public Slider(Unifier<Object> uniOperator, int buckets, int numberOfSlideBuckets)
{
  unifier = uniOperator;
  cache = new LinkedList<>();
  this.numberOfBuckets = buckets;
  this.numberOfSlideBuckets = numberOfSlideBuckets;
}
 

@Override
public Unifier<HashMap<K, ArrayList<V>>> getUnifier()
{
  TopN<K, V> unifier = new TopN<K, V>();
  unifier.setN(getN());
  return unifier;
}
 

public OperatorMeta getSlidingUnifier(int numberOfBuckets, int slidingApplicationWindowCount, int numberOfSlidingWindows)
{
  if (sliderMeta == null) {
    @SuppressWarnings("unchecked")
    Slider slider = new Slider((Unifier<Object>)getUnifier(), numberOfBuckets, numberOfSlidingWindows);
    try {
      sliderMeta = new OperatorMeta(operatorMeta.getName() + '.' + fieldName + "#slider", slider, getUnifierMeta().attributes.clone());
    } catch (CloneNotSupportedException ex) {
      throw new RuntimeException(ex);
    }
    sliderMeta.getAttributes().put(OperatorContext.APPLICATION_WINDOW_COUNT, slidingApplicationWindowCount);
  }
  return sliderMeta;
}
 

@Override
public Unifier<V> getUnifier()
{
  UnifierSumNumber<V> ret = new UnifierSumNumber<V>();
  ret.setVType(getType());
  return ret;
}
 

@Override
public Unifier<Short> getUnifier()
{
  UnifierSumNumber<Short> ret = new UnifierSumNumber<Short>();
  ret.setType(Short.class);
  return ret;
}
 

@Override
public Unifier<Map<String, Object>> getUnifier()
{
  OrderByOperator unifier = new OrderByOperator();
  for (int i = 0; i < getOrderByRules().size(); i++) {
    unifier.addOrderByRule(getOrderByRules().get(i));
  }
  unifier.setDescending(isDescending);
  return unifier;
}
 

@Override
public Unifier<Float> getUnifier()
{
  UnifierSumNumber<Float> ret = new UnifierSumNumber<Float>();
  ret.setType(Float.class);
  return ret;
}
 

@Override
public Unifier<V> getUnifier()
{
  return Max.this;
}
 

@Override
public Unifier<V> getUnifier()
{
  return Min.this;
}
 

@Override
public Unifier<Integer> getUnifier()
{
  return Counter.this;
}
 

@Override
public Unifier<ArrayList<K>> getUnifier()
{
  InsertSort<K> ret = new InsertSort<K>();
  return ret;
}
 

@Override
public Unifier<ArrayList<K>> getUnifier()
{
  return getUnifierInstance();
}
 

@Override
public Unifier<K> getUnifier()
{
  return new Distinct<K>();
}
 

public Unifier<HighLow<Integer>> getUnifier() {
  return  useUnifier ? new UnifierRange<Integer>() : super.getUnifier();
}
 

@Override
public Unifier<HashMap<V, ArrayList<K>>> getUnifier()
{
  return new InvertIndex<K, V>();
}
 

@Override
public Unifier<Number> getUnifier()
{
  return RMin.this;
}
 

@Override
public Unifier<Number> getUnifier()
{
  return RMax.this;
}
 

public UnifierNode(Unifier<Object> unifier, OperatorContext context)
{
  super(unifier, context);
  this.unifier = unifier;
}
 

public Unifier<Object> getUnifier()
{
  return unifier;
}
 

@Override
public Unifier<T> getUnifier()
{
  return outputPort == null ? null : outputPort.getUnifier();
}
 

/**
 * {@inheritDoc}
 *
 * Module developer can override for getUnifier functionality
 */
@Override
public Unifier<T> getUnifier()
{
  return null;
}
 

/**
 *  Get output port unifier instance, sub class should return new instance of itself.
 */
public abstract Unifier<ArrayList<K>> getUnifierInstance();