FunctionBlacklistPolicyFactoryBean.java

/**
 * Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
 * 
 * Please see distribution for license.
 */
package com.opengamma.engine.function.blacklist;

import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
import java.util.concurrent.atomic.AtomicInteger;

import com.opengamma.engine.function.blacklist.FunctionBlacklistPolicy.Entry;
import com.opengamma.id.UniqueId;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.SingletonFactoryBean;

/**
 * Bean for constructing basic {@link FunctionBlacklistPolicy} instances.
 */
public class FunctionBlacklistPolicyFactoryBean extends SingletonFactoryBean<FunctionBlacklistPolicy> {

  private static final AtomicInteger s_nextName = new AtomicInteger(1);

  private UniqueId _uniqueId;
  private String _name = Integer.toString(s_nextName.getAndIncrement());
  private int _defaultEntryActivationPeriod = 3600;
  private int _wildcard;
  private int _function;
  private int _parameterizedFunction;
  private int _partialNode;
  private int _buildNode;
  private int _executionNode;
  private Collection<Entry> _entries;

  // TODO: also allow this bean to be used to create a policy by loading one from a source

  public UniqueId getUniqueId() {
    return _uniqueId;
  }

  public void setUniqueId(final UniqueId uniqueId) {
    _uniqueId = uniqueId;
  }

  public String getName() {
    return _name;
  }

  public void setName(final String name) {
    _name = name;
  }

  public int getDefaultEntryActivationPeriod() {
    return _defaultEntryActivationPeriod;
  }

  public void setDefaultEntryActivationPeriod(final int defaultEntryActivationPeriod) {
    _defaultEntryActivationPeriod = defaultEntryActivationPeriod;
  }

  private boolean is(final int entry) {
    return entry != 0;
  }

  private int set(final int entry, final boolean flag) {
    if (flag) {
      if (entry == 0) {
        return -1;
      } else {
        return entry;
      }
    } else {
      return 0;
    }
  }

  public boolean isWildcard() {
    return is(_wildcard);
  }

  public void setWildcard(final boolean wildcard) {
    _wildcard = set(_wildcard, wildcard);
  }

  public int getWildcardActivationPeriod() {
    return _wildcard;
  }

  public void setWildcardActivationPeriod(final int wildcard) {
    _wildcard = wildcard;
  }

  public boolean isFunction() {
    return is(_function);
  }

  public void setFunction(final boolean function) {
    _function = set(_function, function);
  }

  public int getFunctionActivationPeriod() {
    return _function;
  }

  public void setFunctionActivationPeriod(final int function) {
    _function = function;
  }

  public boolean isParameterizedFunction() {
    return is(_parameterizedFunction);
  }

  public void setParameterizedFunction(final boolean parameterizedFunction) {
    _parameterizedFunction = set(_parameterizedFunction, parameterizedFunction);
  }

  public int getParameterizedFunctionActivationPeriod() {
    return _parameterizedFunction;
  }

  public void setParameterizedFunctionActivationPeriod(final int parameterizedFunction) {
    _parameterizedFunction = parameterizedFunction;
  }

  public boolean isPartialNode() {
    return is(_partialNode);
  }

  public void setPartialNode(final boolean partialNode) {
    _partialNode = set(_partialNode, partialNode);
  }

  public int getPartialNodeActivationPeriod() {
    return _partialNode;
  }

  public void setPartialNodeActivationPeriod(final int partialNode) {
    _partialNode = partialNode;
  }

  public boolean isBuildNode() {
    return is(_buildNode);
  }

  public void setBuildNode(final boolean buildNode) {
    _buildNode = set(_buildNode, buildNode);
  }

  public int getBuildNodeActivationPeriod() {
    return _buildNode;
  }

  public void setBuildNodeActivationPeriod(final int buildNode) {
    _buildNode = buildNode;
  }

  public boolean isExecutionNode() {
    return is(_executionNode);
  }

  public void setExecutionNode(final boolean executionNode) {
    _executionNode = set(_executionNode, executionNode);
  }

  public int getExecutionNodeActivationPeriod() {
    return _executionNode;
  }

  public void setExecutionNodeActivationPeriod(final int executionNode) {
    _executionNode = executionNode;
  }

  public Collection<Entry> getEntries() {
    return _entries;
  }

  public void setEntries(final Collection<Entry> entries) {
    _entries = new ArrayList<Entry>(entries);
  }

  private void create(final Collection<Entry> target, Entry entry, final int flag) {
    if (flag == 0) {
      return;
    }
    if (flag > 0) {
      entry = entry.activationPeriod(flag);
    }
    target.add(entry);
  }

  private Collection<Entry> createEntries() {
    final Collection<Entry> entries = new LinkedList<Entry>();
    if (getEntries() != null) {
      entries.addAll(getEntries());
    }
    create(entries, Entry.WILDCARD, getWildcardActivationPeriod());
    create(entries, Entry.FUNCTION, getFunctionActivationPeriod());
    create(entries, Entry.PARAMETERIZED_FUNCTION, getParameterizedFunctionActivationPeriod());
    create(entries, Entry.PARTIAL_NODE, getPartialNodeActivationPeriod());
    create(entries, Entry.BUILD_NODE, getBuildNodeActivationPeriod());
    create(entries, Entry.EXECUTION_NODE, getExecutionNodeActivationPeriod());
    return entries;
  }

  @Override
  protected FunctionBlacklistPolicy createObject() {
    if (getUniqueId() == null) {
      ArgumentChecker.notNullInjected(getName(), "name");
      setUniqueId(UniqueId.of("com.opengamma.engine.function.blacklist", getName()));
    }
    if (getName() == null) {
      setName(getUniqueId().getValue());
    }
    return new DefaultFunctionBlacklistPolicy(getUniqueId(), getName(), getDefaultEntryActivationPeriod(), createEntries());
  }

}