brainslug.flow.execution.instance.HashMapInstanceStore Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of brainslug-execution Show documentation
The newest version!
package brainslug.flow.execution.instance;

import brainslug.flow.execution.token.TokenStore;
import brainslug.flow.definition.Identifier;
import brainslug.flow.execution.property.store.PropertyStore;
import brainslug.flow.expression.EqualsExpression;
import brainslug.flow.expression.Property;
import brainslug.flow.expression.Value;
import brainslug.util.IdGenerator;
import brainslug.util.Option;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class HashMapInstanceStore implements InstanceStore {
    final IdGenerator idGenerator;
    final PropertyStore propertyStore;
    private TokenStore tokenStore;
    final Map> instancesByDefinitionId;
    final Map instancesById;

    public HashMapInstanceStore(IdGenerator idGenerator, PropertyStore propertyStore, TokenStore tokenStore) {
        this.idGenerator = idGenerator;
        this.propertyStore = propertyStore;
        this.tokenStore = tokenStore;
        this.instancesByDefinitionId = new ConcurrentHashMap>();
        this.instancesById = new ConcurrentHashMap();
    }

    @Override
    public List findInstances(FlowInstanceSelector instanceSelector) {
      return filterProperties(instanceSelector.properties(), instancesByFlowIdAndInstanceId(instanceSelector));
    }

    private List filterProperties(Collection, Value>> propertyExpressions, List flowInstances) {
        if (propertyExpressions.isEmpty()) {
            return flowInstances;
        }

        List filteredInstances = new ArrayList();

        for (FlowInstance flowInstance : flowInstances) {
          FlowInstanceProperties> instanceProperties = propertyStore.getProperties(flowInstance.getIdentifier());

          for (EqualsExpression, Value> propertyExpression : propertyExpressions) {
              FlowInstanceProperty propertyValue = instanceProperties.get(propertyExpression.getLeft().getValue().stringValue());

              if (propertyValue != null && propertyValue.getValue().equals(propertyExpression.getRight().getValue())) {
                filteredInstances.add(flowInstance);
              }
          }
        }

        return filteredInstances;
    }

    private List instancesByFlowIdAndInstanceId(FlowInstanceSelector instanceSelector) {
      if (!instanceSelector.definitionId().isPresent() && !instanceSelector.instanceId().isPresent()) {
          throw new IllegalArgumentException("you need to specify either instance or definition identifier");
      } else if (instanceSelector.definitionId().isPresent() && !instanceSelector.instanceId().isPresent()) {
          return instancesByDefinitionId(instanceSelector.definitionId().get());
      } else if (instanceSelector.instanceId().isPresent() && instanceSelector.definitionId().isPresent()) {
          return emptyOrSingletonListFromNullable(instanceByDefinitionIdAndInstanceId(instanceSelector));
      } else {
          return emptyOrSingletonListFromNullable(instanceByInstanceId(instanceSelector.instanceId().get()).orElse(null));
      }
    }

    List emptyOrSingletonListFromNullable(FlowInstance instance) {
        if (instance == null) {
            return Collections.emptyList();
        }
        return Collections.singletonList(instance);
    }

    protected FlowInstance instanceByDefinitionIdAndInstanceId(FlowInstanceSelector instanceSelector) {
        return getOrCreateInstanceMap(instanceSelector.definitionId().get()).get(instanceSelector.instanceId().get());
    }

    @Override
    public Option findInstance(FlowInstanceSelector instanceSelector) {
        List instances = filterProperties(instanceSelector.properties(), instancesByFlowIdAndInstanceId(instanceSelector));
        if (instances.isEmpty()) {
            return Option.empty();
        }
        return Option.of(instances.get(0));
    }

    protected List instancesByDefinitionId(Identifier definitionId) {
        return new ArrayList(getOrCreateInstanceMap(definitionId).values());
    }

    protected Option instanceByInstanceId(Identifier instanceId) {
        return Option.of(instancesById.get(instanceId));
    }

    @Override
    public FlowInstance createInstance(Identifier definitionId) {
        Identifier instanceId = idGenerator.generateId();
        DefaultFlowInstance newInstance = new DefaultFlowInstance(instanceId, definitionId, propertyStore, tokenStore);

        addInstanceToDefinitionInstances(definitionId, newInstance);
        instancesById.put(instanceId, newInstance);

        return newInstance;
    }

    private List addInstanceToDefinitionInstances(Identifier definitionId, DefaultFlowInstance newInstance) {
        Map definitionInstanceMap = getOrCreateInstanceMap(definitionId);
        definitionInstanceMap.put(newInstance.getIdentifier(), newInstance);

        return new ArrayList(definitionInstanceMap.values());
    }

    private Map getOrCreateInstanceMap(Identifier definitionId) {
        if (instancesByDefinitionId.get(definitionId) == null) {
            instancesByDefinitionId.put(definitionId, new ConcurrentHashMap());
        }
        return instancesByDefinitionId.get(definitionId);
    }
}