Package it.unive.lisa.analysis.lattices

Class FunctionalLattice<F extends FunctionalLattice<F,​K,​V>,​K,​V extends Lattice<V>>

    • Field Summary

      Fields 
      Modifier and Type Field Description
      java.util.Map<K,​V> function
      The function implemented by this lattice.
      V lattice
      The underlying lattice.

    • Constructor Summary

      Constructors 
      Constructor Description
      FunctionalLattice​(V lattice)
      Builds the lattice.
      FunctionalLattice​(V lattice, java.util.Map<K,​V> function)
      Builds the lattice by cloning the given function.

    • Method Summary

      All Methods Instance Methods Abstract Methods Concrete Methods 
      Modifier and Type Method Description
      boolean equals​(java.lang.Object obj)  
      F functionalLift​(F other, V missing, FunctionalLattice.KeyFunctionalLift<K> keyLifter, FunctionalLattice.FunctionalLift<V> valueLifter)
      Yields the functional lift between this and other.
      java.util.Set<K> getKeys()
      Yields the set of keys currently in this lattice.
      java.util.Map<K,​V> getMap()
      Yields the map associated with this functional lattice element.
      V getOtDefault​(K key, V def)
      Similar to getState(Object), but yields a custom default value for keys that are not part of the mapping (instead of using stateOfUnknown(Object)).
      V getState​(K key)
      Yields the state associated to the given key.
      java.util.Collection<V> getValues()
      Yields the values of this functional lattice.
      F glbAux​(F other)
      Performs the greatest lower bound operation between this lattice element and the given one, assuming that base cases have already been handled.
      java.util.Set<K> glbKeys​(java.util.Set<K> k1, java.util.Set<K> k2)
      Yields the intersection of the keys between k1 and k2.
      int hashCode()  
      boolean isBottom()
      Yields true if and only if this object represents the bottom of the lattice.
      boolean isTop()
      Yields true if and only if this object represents the top of the lattice.
      java.util.Iterator<java.util.Map.Entry<K,​V>> iterator()  
      boolean lessOrEqualAux​(F other)
      Yields true if and only if this lattice element is in relation with (usually represented through ≤) the given one, assuming that base cases have already been handled.
      F lubAux​(F other)
      Performs the least upper bound operation between this lattice element and the given one, assuming that base cases have already been handled.
      java.util.Set<K> lubKeys​(java.util.Set<K> k1, java.util.Set<K> k2)
      Yields the union of the keys between k1 and k2.
      abstract F mk​(V lattice, java.util.Map<K,​V> function)
      Builds a instance of this class from the given lattice instance and the given mapping.
      java.util.Map<K,​V> mkNewFunction​(java.util.Map<K,​V> other, boolean preserveNull)
      Creates a new instance of the underlying function.
      F narrowingAux​(F other)
      Performs the narrowing operation between this lattice element and the given one, assuming that base cases have already been handled.
      F putState​(K key, V state)
      Yields an instance of this class equal to the receiver of the call, but with key mapped to state.
      StructuredRepresentation representation()
      Yields a StructuredRepresentation of the information contained in this object's instance.
      abstract V stateOfUnknown​(K key)
      Yields the value that should be returned by getState(Object) whenever the given key is not present in this map.
      java.lang.String toString()  
      F wideningAux​(F other)
      Performs the widening operation between this lattice element and the given one, assuming that base cases have already been handled.

      • Methods inherited from class java.lang.Object

        clone, finalize, getClass, notify, notifyAll, wait, wait, wait

      • Methods inherited from interface java.lang.Iterable

        forEach, spliterator

    • Field Detail

      • function

        public java.util.Map<K,​V extends Lattice<V>> function
        The function implemented by this lattice.

      • lattice

        public final V extends Lattice<V> lattice
        The underlying lattice.

    • Constructor Detail

      • FunctionalLattice

        public FunctionalLattice​(V lattice)
        Builds the lattice.
        Parameters:
        lattice - the underlying lattice

      • FunctionalLattice

        public FunctionalLattice​(V lattice,
                         java.util.Map<K,​V> function)
        Builds the lattice by cloning the given function.
        Parameters:
        lattice - the underlying lattice
        function - the function to clone

    • Method Detail

      • mkNewFunction

        public java.util.Map<K,​V> mkNewFunction​(java.util.Map<K,​V> other,
                                              boolean preserveNull)
        Creates a new instance of the underlying function. The purpose of this method is to provide a common function implementation to every subclass that does not have implementation-specific requirements.
        Parameters:
        other - an optional function to copy, can be null
        preserveNull - whether a null other should cause a null return value or an empty function
        Returns:
        a new function

      • getKeys

        public java.util.Set<K> getKeys()
        Yields the set of keys currently in this lattice.
        Returns:
        the set of keys

      • getState

        public V getState​(K key)
        Yields the state associated to the given key. This operation is defined in term of lattices: it always returns bottom of isBottom() holds, top if isTop() holds, the stored value when key is part of the mapping, or stateOfUnknown(Object) otherwise. This method is the primary way in which information mapped to a key should be extracted from this function.
        Parameters:
        key - the key
        Returns:
        the state

      • getOtDefault

        public V getOtDefault​(K key,
                      V def)
        Similar to getState(Object), but yields a custom default value for keys that are not part of the mapping (instead of using stateOfUnknown(Object)). This is useful for implementing specific operation that need to use an operation-neutral element as fallback.
        Parameters:
        key - the key
        def - the default value to return when there is no mapping for key
        Returns:
        the state

      • stateOfUnknown

        public abstract V stateOfUnknown​(K key)
        Yields the value that should be returned by getState(Object) whenever the given key is not present in this map.
        Parameters:
        key - the key that is missing
        Returns:
        the lattice element for keys not in the mapping

      • putState

        public F putState​(K key,
                  V state)
        Yields an instance of this class equal to the receiver of the call, but with key mapped to state.
        Parameters:
        key - the key
        state - the state
        Returns:
        the new instance of this class with the updated mapping

      • mk

        public abstract F mk​(V lattice,
                     java.util.Map<K,​V> function)
        Builds a instance of this class from the given lattice instance and the given mapping.
        Parameters:
        lattice - an instance of lattice to be used during semantic operations to retrieve top and bottom values
        function - the function representing the mapping contained in the new environment; can be null
        Returns:
        a new instance of this class

      • lubAux

        public F lubAux​(F other)
         throws SemanticException
        Description copied from interface: BaseLattice
        Performs the least upper bound operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:
        • other is not null
        • other is neither top nor bottom
        • this is neither top nor bottom
        • this and other are not the same object (according both to == and to Object.equals(Object))
        Specified by:
        lubAux in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Parameters:
        other - the other lattice element
        Returns:
        the least upper bound between this and other
        Throws:
        SemanticException - if an error occurs during the computation

      • glbAux

        public F glbAux​(F other)
         throws SemanticException
        Description copied from interface: BaseLattice
        Performs the greatest lower bound operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:
        • other is not null
        • other is neither top nor bottom
        • this is neither top nor bottom
        • this and other are not the same object (according both to == and to Object.equals(Object))
        Specified by:
        glbAux in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Parameters:
        other - the other lattice element
        Returns:
        the greatest lower bound between this and other
        Throws:
        SemanticException - if an error occurs during the computation

      • wideningAux

        public F wideningAux​(F other)
              throws SemanticException
        Description copied from interface: BaseLattice
        Performs the widening operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:
        • other is not null
        • other is neither top nor bottom
        • this is neither top nor bottom
        • this and other are not the same object (according both to == and to Object.equals(Object))
        The default implementation of this method delegates to BaseLattice.lubAux(BaseLattice), and is thus safe for finite lattices and ACC ones.
        Specified by:
        wideningAux in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Parameters:
        other - the other lattice element
        Returns:
        the widening between this and other
        Throws:
        SemanticException - if an error occurs during the computation

      • narrowingAux

        public F narrowingAux​(F other)
               throws SemanticException
        Description copied from interface: BaseLattice
        Performs the narrowing operation between this lattice element and the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:
        • other is not null
        • other is neither top nor bottom
        • this is neither top nor bottom
        • this and other are not the same object (according both to == and to Object.equals(Object))
        The default implementation of this method delegates to BaseLattice.glbAux(BaseLattice), and is thus safe for finite lattices and DCC ones.
        Specified by:
        narrowingAux in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Parameters:
        other - the other lattice element
        Returns:
        the narrowing between this and other
        Throws:
        SemanticException - if an error occurs during the computation

      • functionalLift

        public F functionalLift​(F other,
                        V missing,
                        FunctionalLattice.KeyFunctionalLift<K> keyLifter,
                        FunctionalLattice.FunctionalLift<V> valueLifter)
                 throws SemanticException
        Yields the functional lift between this and other.
        Parameters:
        other - the other functional lattice
        missing - the lattice element to use for the lift when a key has no mapping in one of the two functions (e.g., for lub, missing should be bottom, while for glb it should be top)
        keyLifter - the key lifter
        valueLifter - the value lifter
        Returns:
        the intersection between k1 and k2
        Throws:
        SemanticException - if something goes wrong while lifting the lattice elements

      • lubKeys

        public java.util.Set<K> lubKeys​(java.util.Set<K> k1,
                                java.util.Set<K> k2)
                         throws SemanticException
        Yields the union of the keys between k1 and k2.
        Parameters:
        k1 - the first key set
        k2 - the second key set
        Returns:
        the union between k1 and k2
        Throws:
        SemanticException - if something goes wrong while lifting the keys

      • glbKeys

        public java.util.Set<K> glbKeys​(java.util.Set<K> k1,
                                java.util.Set<K> k2)
                         throws SemanticException
        Yields the intersection of the keys between k1 and k2.
        Parameters:
        k1 - the first key set
        k2 - the second key set
        Returns:
        the intersection between k1 and k2
        Throws:
        SemanticException - if something goes wrong while lifting the key sets

      • lessOrEqualAux

        public boolean lessOrEqualAux​(F other)
                       throws SemanticException
        Description copied from interface: BaseLattice
        Yields true if and only if this lattice element is in relation with (usually represented through ≤) the given one, assuming that base cases have already been handled. In particular, it is guaranteed that:
        • other is not null
        • other is neither top nor bottom
        • this is neither top nor bottom
        • this and other are not the same object (according both to == and to Object.equals(Object))
        Specified by:
        lessOrEqualAux in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Parameters:
        other - the other lattice element
        Returns:
        true if and only if that condition holds
        Throws:
        SemanticException - if an error occurs during the computation

      • isTop

        public boolean isTop()
        Yields true if and only if this object represents the top of the lattice. The default implementation of this method uses reference equality between this and the value returned by Lattice.top(), thus assuming that the top element is a singleton. If this is not the case, override this method accordingly to provide a coherent test.

        By default, a functional lattice is the top lattice if the underlying lattice's isTop() holds and its function is null.
        Specified by:
        isTop in interface Lattice<F extends FunctionalLattice<F,​K,​V>>
        Returns:
        true if this is the top of the lattice

      • isBottom

        public boolean isBottom()
        Yields true if and only if this object represents the bottom of the lattice. The default implementation of this method uses reference equality between this and the value returned by Lattice.bottom(), thus assuming that the bottom element is a singleton. If this is not the case, override this method accordingly to provide a coherent test.

        By default, a functional lattice is the top lattice if the underlying lattice's isBottom() holds and its function is null.
        Specified by:
        isBottom in interface Lattice<F extends FunctionalLattice<F,​K,​V>>
        Returns:
        true if this is the bottom of the lattice

      • equals

        public boolean equals​(java.lang.Object obj)
        Specified by:
        equals in interface BaseLattice<F extends FunctionalLattice<F,​K,​V>>
        Overrides:
        equals in class java.lang.Object

      • iterator

        public java.util.Iterator<java.util.Map.Entry<K,​V>> iterator()
        Specified by:
        iterator in interface java.lang.Iterable<F extends FunctionalLattice<F,​K,​V>>

      • getValues

        public java.util.Collection<V> getValues()
        Yields the values of this functional lattice.
        Returns:
        the values of this functional lattice

      • getMap

        public java.util.Map<K,​V> getMap()
        Yields the map associated with this functional lattice element.
        Returns:
        the map associated with this functional lattice element.