/*

  * Licensed to the Apache Software Foundation (ASF) under one or more

  * contributor license agreements.  See the NOTICE file distributed with

  * this work for additional information regarding copyright ownership.

  * The ASF licenses this file to You under the Apache License, Version 2.0

  * (the "License"); you may not use this file except in compliance with

  * the License.  You may obtain a copy of the License at

  *

  *      http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 package org.apache.commons.nabla.forward.analysis;

 import java.util.HashSet;

 import java.util.Set;

 import org.objectweb.asm.Type;

 import org.objectweb.asm.tree.AbstractInsnNode;

 import org.objectweb.asm.tree.analysis.Value;

 /** A value that keep track of both instructions producing and consuming it.

  * @version $Id$

  */

 public class TrackingValue implements Value {

     /** Special value for uninitialized values. */

     public static final TrackingValue UNINITIALIZED_VALUE = new TrackingValue(null);

     /** Value type. */

     private final Type type;

     /** Instructions that consume this value. */

     private Set<AbstractInsnNode> consumers;

     /** Instructions that produce this value. */

     private Set<AbstractInsnNode> producers;

     /** Values that are merged with this value (including the instance itself). */

     private Set<TrackingValue> merged;

     /** Build a new value without any link to instructions.

      * @param type value type

      */

     public TrackingValue(final Type type) {

         this.type  = type;

         consumers  = new HashSet<AbstractInsnNode>();

         producers  = new HashSet<AbstractInsnNode>();

         merged     = new HashSet<TrackingValue>();

         merged.add(this);

     }

     /** Build a new value produced by a specified instruction.

      * @param type value type

      * @param producer producer for this value

      */

     public TrackingValue(final Type type, final AbstractInsnNode producer) {

         this(type);

         producers.add(producer);

     }

     /** Get the value type.

      * @return value type

      */

     public Type getType() {

         return type;

     }

     /** {@inheritDoc} */

     public int getSize() {

         return type == Type.LONG_TYPE || type == Type.DOUBLE_TYPE ? 2 : 1;

     }

     /** Add a consumer for this value.

      * @param consumer consumer for this value

      */

     public void addConsumer(final AbstractInsnNode consumer) {

         consumers.add(consumer);

     }

     /** Get the consumers for this value and all values it is merged with.

      * @return the instructions consuming either this value or the values

      * it has been merged with

      */

     public Set<AbstractInsnNode> getConsumers() {

         return consumers;

     }

     /** Add a producer for this value.

      * @param producer producer for this value

      */

     public void addProducer(final AbstractInsnNode producer) {

         producers.add(producer);

     }

     /** Get the producers for this value and all values it is merged with.

      * @return the instructions producing either this value or the values

      * it has been merged with

      */

     public Set<AbstractInsnNode> getProducers() {

         return producers;

     }

     /** Merge two instances.

      * <p>Once merged, values share the same producers and consumers sets.</p>

      * @param value1 first value to merge

      * @param value2 second value to merge

      */

     public static void merge(final TrackingValue value1, final TrackingValue value2) {

         if (value1.merged.contains(value2)) {

             // the values have already been merged

             return;

         }

         // merge the sets

         value1.consumers.addAll(value2.consumers);

         value1.producers.addAll(value2.producers);

         value1.merged.addAll(value2.merged);

         // share the merged sets

         for (final TrackingValue value : value2.merged) {

             value.consumers = value1.consumers;

             value.producers = value1.producers;

             value.merged    = value1.merged;

         }

     }

 }