expstdop.java

UML设计测试工具

    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isBoolean()
                 && params[1].isBoolean() )
            ? params[0] : null;
    }

    public Value evalWithArgs(EvalContext ctx, Expression args[]) {
        Value v1 = args[0].eval(ctx);
        if (v1.isUndefined() ) 
            return v1;

        boolean b1 = ((BooleanValue) v1).value();
        Value v2 = args[1].eval(ctx);
        if (! b1 )
            return v2;
        else {
            if (v2.isUndefined() )
                return v2;
            boolean b2 = ((BooleanValue) v2).value();
            return ( b2 ) ? BooleanValue.FALSE : BooleanValue.TRUE;
        }
    }
}

// --------------------------------------------------------

/* and : Boolean x Boolean -> Boolean */
final class Op_boolean_and extends BooleanOperation {
    public String name() { return "and"; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isBoolean()
                 && params[1].isBoolean() )
            ? params[0] : null;
    }

    public Value evalWithArgs(EvalContext ctx, Expression args[]) {
        Value v1 = args[0].eval(ctx);
        if (v1.isDefined() ) {
            boolean b1 = ((BooleanValue) v1).value();
            if (! b1 ) 
                return BooleanValue.FALSE;
            else {
                Value v2 = args[1].eval(ctx);
                return v2;
            }
        } else {
            Value v2 = args[1].eval(ctx);
            if (v2.isDefined() ) {
                boolean b2 = ((BooleanValue) v2).value();
                if (! b2 )
                    return BooleanValue.FALSE;
            }
            return new UndefinedValue(TypeFactory.mkBoolean());
        }
    }
}

// --------------------------------------------------------

/* not : Boolean -> Boolean */
final class Op_boolean_not extends BooleanOperation {
    public String name() { return "not"; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isBoolean() )
            ? params[0] : null;
    }

    public Value evalWithArgs(EvalContext ctx, Expression args[]) {
        Value v = args[0].eval(ctx);
        if (v.isUndefined() )
            return v;
        boolean b = ((BooleanValue) v).value();
        return ( b ) ? BooleanValue.FALSE : BooleanValue.TRUE;
    }
}

// --------------------------------------------------------

/* implies : Boolean x Boolean -> Boolean */
final class Op_boolean_implies extends BooleanOperation {
    public String name() { return "implies"; }
    public boolean isInfixOrPrefix() { return true; }

    public Type matches(Type params[]) {
        return ( params.length == 2
                 && params[0].isBoolean()
                 && params[1].isBoolean() )
            ? params[0] : null;
    }

    public Value evalWithArgs(EvalContext ctx, Expression args[]) {
        Value v1 = args[0].eval(ctx);
        if (v1.isDefined() ) {
            boolean b1 = ((BooleanValue) v1).value();
            if (! b1 ) 
                return BooleanValue.TRUE;
            else {
                Value v2 = args[1].eval(ctx);
                return v2;
            }
        } else {
            Value v2 = args[1].eval(ctx);
            if (v2.isDefined() ) {
                boolean b2 = ((BooleanValue) v2).value();
                if (b2 )
                    return BooleanValue.TRUE;
            }
            return new UndefinedValue(TypeFactory.mkBoolean());
        }
    }
}

// --------------------------------------------------------
// 
// Collection operations. 
//
// --------------------------------------------------------

/* size : Collection(T) -> Integer */
final class Op_collection_size extends OpGeneric {
    public String name() { return "size"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isCollection() )
            ? TypeFactory.mkInteger() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll = (CollectionValue) args[0];
        return new IntegerValue(coll.size());
    }
}

// --------------------------------------------------------

/* includes : Collection(T2) x T1 -> Boolean,  with T2 <= T1 */
final class Op_collection_includes extends OpGeneric {
    public String name() { return "includes"; }

    // may test for undefined being an element of the collection
    public int kind() { return SPECIAL; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 2 && params[0].isCollection() ) {
            CollectionType coll = (CollectionType) params[0];
            if (params[1].isSubtypeOf(coll.elemType()) )
                return TypeFactory.mkBoolean();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        if (args[0].isUndefined() )
            return BooleanValue.FALSE;
        CollectionValue coll = (CollectionValue) args[0];
        boolean res = coll.includes(args[1]);
        return BooleanValue.get(res);
    }
}

// --------------------------------------------------------

/* excludes : Collection(T2) x T1 -> Boolean,  with T2 <= T1 */
final class Op_collection_excludes extends OpGeneric {
    public String name() { return "excludes"; }

    // may test for undefined being an element of the collection
    public int kind() { return SPECIAL; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 2 && params[0].isCollection() ) {
            CollectionType coll = (CollectionType) params[0];
            if (params[1].isSubtypeOf(coll.elemType()) )
                return TypeFactory.mkBoolean();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        if (args[0].isUndefined() )
            return BooleanValue.FALSE;
        CollectionValue coll = (CollectionValue) args[0];
        boolean res = ! coll.includes(args[1]);
        return BooleanValue.get(res);
    }
}

// --------------------------------------------------------

/* count : Collection(T) x T -> Integer */
final class Op_collection_count extends OpGeneric {
    public String name() { return "count"; }
    // may count occurrences of undefined in the collection
    public int kind() { return SPECIAL; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 2 && params[0].isCollection() ) {
            CollectionType coll = (CollectionType) params[0];
            if (params[1].isSubtypeOf(coll.elemType()) )
                return TypeFactory.mkInteger();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        if (args[0].isUndefined() )
            return new IntegerValue(0);
        CollectionValue coll = (CollectionValue) args[0];
        int res = coll.count(args[1]);
        return new IntegerValue(res);
    }
}

// --------------------------------------------------------

/* includesAll : Collection(T) x Collection(T) -> Boolean */
final class Op_collection_includesAll extends OpGeneric {
    public String name() { return "includesAll"; }
    public int kind() { return OPERATION; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 2 
            && params[0].isCollection() 
            && params[1].isCollection() ) {
            CollectionType coll1 = (CollectionType) params[0];
            CollectionType coll2 = (CollectionType) params[1];
            Type t = coll1.elemType();
            if (coll2.isSubtypeOf(TypeFactory.mkCollection(t)) )
                return TypeFactory.mkBoolean();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll1 = (CollectionValue) args[0];
        CollectionValue coll2 = (CollectionValue) args[1];
        boolean res = coll1.includesAll(coll2);
        return BooleanValue.get(res);
    }
}

// --------------------------------------------------------

/* excludesAll : Collection(T) x Collection(T) -> Boolean */
final class Op_collection_excludesAll extends OpGeneric {
    public String name() { return "excludesAll"; }
    public int kind() { return OPERATION; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 2 
            && params[0].isCollection() 
            && params[1].isCollection() ) {
            CollectionType coll1 = (CollectionType) params[0];
            CollectionType coll2 = (CollectionType) params[1];
            Type t = coll1.elemType();
            if (coll2.isSubtypeOf(TypeFactory.mkCollection(t)) )
                return TypeFactory.mkBoolean();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll1 = (CollectionValue) args[0];
        CollectionValue coll2 = (CollectionValue) args[1];
        boolean res = coll1.excludesAll(coll2);
        return BooleanValue.get(res);
    }
}

// --------------------------------------------------------

/* isEmpty : Collection(T) -> Boolean */
final class Op_collection_isEmpty extends OpGeneric {
    public String name() { return "isEmpty"; }
    public int kind() { return PREDICATE; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isCollection() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll = (CollectionValue) args[0];
        return BooleanValue.get(coll.isEmpty());
    }
}

// --------------------------------------------------------

/* notEmpty : Collection(T) -> Boolean */
final class Op_collection_notEmpty extends OpGeneric {
    public String name() { return "notEmpty"; }
    public int kind() { return PREDICATE; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        return ( params.length == 1 && params[0].isCollection() )
            ? TypeFactory.mkBoolean() : null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll = (CollectionValue) args[0];
        return BooleanValue.get(! coll.isEmpty());
    }
}

// --------------------------------------------------------

/* sum : Collection(T) -> T */
final class Op_collection_sum extends OpGeneric {
    public String name() { return "sum"; }
    public int kind() { return OPERATION; }
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 1 && params[0].isCollection() ) {
            CollectionType c = (CollectionType) params[0];
            if (c.elemType().isInteger() )
                return TypeFactory.mkInteger();
            else if (c.elemType().isReal() )
                return TypeFactory.mkReal();
        }
        return null;
    }

    public Value eval(EvalContext ctx, Value[] args, Type resultType) {
        CollectionValue coll = (CollectionValue) args[0];
        boolean isIntegerCollection = coll.elemType().isInteger();
        Iterator it = coll.iterator();
        if (isIntegerCollection ) {
            int isum = 0;
            while (it.hasNext() ) {
                Value v = (Value) it.next();
                if (v.isUndefined() )
                    return new UndefinedValue(TypeFactory.mkInteger());
                isum += ((IntegerValue) v).value();
            }
            return new IntegerValue(isum);
        } else {
            double rsum = 0.0;
            while (it.hasNext() ) {
                Value v = (Value) it.next();
                if (v.isUndefined() )
                    return new UndefinedValue(TypeFactory.mkReal());
                if (v.isInteger() )
                    rsum += ((IntegerValue) v).value();
                else
                    rsum += ((RealValue) v).value();
            }
            return new RealValue(rsum);
        }
    }
}

// --------------------------------------------------------

/* flatten : C1(C2(T)) -> C1(T) */
final class Op_collection_flatten extends OpGeneric {
    public String name() { return "flatten"; }
    public int kind() { return OPERATION; } 
    public boolean isInfixOrPrefix() { return false; }

    public Type matches(Type params[]) {
        if (params.length == 1 && params[0].isCollection() ) {
            CollectionType c1 = (CollectionType) params[0];
            if (c1.elemType().isCollection() ) {
                CollectionType c2 = (CollectionType) c1.elemType();
                if (c1.isSet() )
                    return TypeFactory.mkSet(c2.elemType());
                else if (c1.isBag() )
                    return TypeFactory.mkBag(c2.elemType());
                else if (c1.isSequence() /*&& c2.isSequence()*/ )
                    return TypeFactory.mkSequence(c2.elemType());
            }
        }
        return null;