Package gnu.kawa.lispexpr

Class SeqSizeType

  • All Implemented Interfaces:
    TypeValue, Type
    public class SeqSizeType
extends LangObjType
    This matches a sequences of a specific length. This is used for [pat1 ... panN] patterns.

    • Constructor Detail

      • SeqSizeType

        public SeqSizeType​(String name,
                   int requiredSize,
                   boolean requiredExact,
                   String implClass)

      • SeqSizeType

        public SeqSizeType​(int requiredSize,
                   boolean requiredExact)

    • Method Detail

      • coerceFromObject

        public Object coerceFromObject​(Object obj)
        Description copied from class: Type
        Convert an object to a value of this Type. The result is actually of the implementation type, boxed as appropriate, so it is suitable for standard reflective operations, like the arguments to Field#set or Method#invoke. Throw a ClassCastException when this is not possible.
        Overrides:
        coerceFromObject in class LangObjType

      • checkSizeEq

        public static void checkSizeEq​(List list,
                               int requiredSize)

      • checkSizeGe

        public static void checkSizeGe​(List list,
                               int requiredSize)

      • coerceEq

        public static List coerceEq​(Object object,
                            int requiredSize)

      • coerceGe

        public static List coerceGe​(Object object,
                            int requiredSize)

      • coerceEqOrNull

        public static List coerceEqOrNull​(Object object,
                                  int requiredSize)

      • coerceGeOrNull

        public static List coerceGeOrNull​(Object object,
                                  int requiredSize)

      • isCompatibleWithValue

        public int isCompatibleWithValue​(Type valueType)
        Description copied from class: Type
        If this is the target type, is a given source type compatible?
        Overrides:
        isCompatibleWithValue in class LangObjType
        Returns:
        -1 if not compatible; 0 if need to check at run-time; 1 if compatible; 2 if compatible and no conversion or cast needed. We also return 0 for some "narrowing" conversions even if we know they will always succeed, so as to make such conversions less preferred when doing method overloading.

      • isInterface

        public boolean isInterface()
        Overrides:
        isInterface in class Type

      • compare

        public int compare​(Type other)
        Description copied from class: Type
        Return a numeric code showing "subtype" relationship: 1: if other is a pure subtype of this; 0: if has the same values; -1: if this is a pure subtype of other; -2: if they have values in common but neither is a subtype of the other; -3: if the types have no values in common. "Same values" is rather loose; by "A is a subtype of B" we mean that all instance of A can be "widened" to B. More formally, A.compare(B) returns: 1: all B values can be converted to A without a coercion failure (i.e. a ClassCastException or overflow or major loss of information), but not vice versa. 0: all A values can be converted to B without a coercion failure and vice versa; -1: all A values can be converted to B without a coercion failure but not vice versa; -2: there are (potentially) some A values that can be converted to B, and some B values can be converted to A; -3: there are no A values that can be converted to B, and neither are there any B values that can be converted to A.
        Overrides:
        compare in class LangObjType