Examples with Type com.acgist.snail.pojo.bean.M3u8.Type used on opensource projects

Example 16 with Type

use of com.acgist.snail.pojo.bean.M3u8.Type in project cel-java by projectnessie.

the class CheckerEnv method sanitizeFunction.

// sanitizeFunction replaces well-known types referenced by message name with their equivalent
// CEL built-in type instances.
Decl sanitizeFunction(Decl decl) {
    FunctionDecl fn = decl.getFunction();
    // Determine whether the declaration requires replacements from proto-based message type
    // references to well-known CEL type references.
    boolean needsSanitizing = false;
    for (Overload o : fn.getOverloadsList()) {
        if (isObjectWellKnownType(o.getResultType())) {
            needsSanitizing = true;
            break;
        }
        for (Type p : o.getParamsList()) {
            if (isObjectWellKnownType(p)) {
                needsSanitizing = true;
                break;
            }
        }
    }
    // Early return if the declaration requires no modification.
    if (!needsSanitizing) {
        return decl;
    }
    // Sanitize all of the overloads if any overload requires an update to its type references.
    List<Overload> overloads = new ArrayList<>(fn.getOverloadsCount());
    for (Overload o : fn.getOverloadsList()) {
        boolean sanitized = false;
        Type rt = o.getResultType();
        if (isObjectWellKnownType(rt)) {
            rt = getObjectWellKnownType(rt);
            sanitized = true;
        }
        List<Type> params = new ArrayList<>(o.getParamsCount());
        for (Type p : o.getParamsList()) {
            if (isObjectWellKnownType(p)) {
                params.add(getObjectWellKnownType(p));
                sanitized = true;
            } else {
                params.add(p);
            }
        }
        // If sanitized, replace the overload definition.
        Overload ov;
        if (sanitized) {
            if (o.getIsInstanceFunction()) {
                ov = Decls.newInstanceOverload(o.getOverloadId(), params, rt);
            } else {
                ov = Decls.newOverload(o.getOverloadId(), params, rt);
            }
        } else {
            // Otherwise, preserve the original overload.
            ov = o;
        }
        overloads.add(ov);
    }
    return Decls.newFunction(decl.getName(), overloads);
}

Example 17 with Type

use of com.acgist.snail.pojo.bean.M3u8.Type in project cel-java by projectnessie.

the class CheckerEnv method addOverload.

/**
 * addOverload adds overload to function declaration f. Returns one or more errorMsg values if the
 * overload overlaps with an existing overload or macro.
 */
Decl addOverload(Decl f, Overload overload, List<String> errMsgs) {
    FunctionDecl function = f.getFunction();
    Mapping emptyMappings = newMapping();
    Type overloadFunction = Decls.newFunctionType(overload.getResultType(), overload.getParamsList());
    Type overloadErased = substitute(emptyMappings, overloadFunction, true);
    boolean hasErr = false;
    for (Overload existing : function.getOverloadsList()) {
        Type existingFunction = Decls.newFunctionType(existing.getResultType(), existing.getParamsList());
        Type existingErased = substitute(emptyMappings, existingFunction, true);
        boolean overlap = isAssignable(emptyMappings, overloadErased, existingErased) != null || isAssignable(emptyMappings, existingErased, overloadErased) != null;
        if (overlap && overload.getIsInstanceFunction() == existing.getIsInstanceFunction()) {
            errMsgs.add(overlappingOverloadError(f.getName(), overload.getOverloadId(), overloadFunction, existing.getOverloadId(), existingFunction));
            hasErr = true;
        }
    }
    for (Macro macro : Macro.AllMacros) {
        if (macro.function().equals(f.getName()) && macro.isReceiverStyle() == overload.getIsInstanceFunction() && macro.argCount() == overload.getParamsCount()) {
            errMsgs.add(overlappingMacroError(f.getName(), macro.argCount()));
            hasErr = true;
        }
    }
    if (hasErr) {
        return f;
    }
    function = function.toBuilder().addOverloads(overload).build();
    f = f.toBuilder().setFunction(function).build();
    return f;
}

Example 18 with Type

use of com.acgist.snail.pojo.bean.M3u8.Type in project cel-java by projectnessie.

the class CheckerEnv method lookupIdent.

/**
 * LookupIdent returns a Decl proto for typeName as an identifier in the Env. Returns nil if no
 * such identifier is found in the Env.
 */
public Decl lookupIdent(String name) {
    for (String candidate : container.resolveCandidateNames(name)) {
        Decl ident = declarations.findIdent(candidate);
        if (ident != null) {
            return ident;
        }
        // Next try to import the name as a reference to a message type. If found,
        // the declaration is added to the outest (global) scope of the
        // environment, so next time we can access it faster.
        Type t = provider.findType(candidate);
        if (t != null) {
            Decl decl = Decls.newVar(candidate, t);
            declarations.addIdent(decl);
            return decl;
        }
        // Next try to import this as an enum value by splitting the name in a type prefix and
        // the enum inside.
        Val enumValue = provider.enumValue(candidate);
        if (enumValue.type() != ErrType) {
            Decl decl = Decls.newIdent(candidate, Decls.Int, Constant.newBuilder().setInt64Value(enumValue.intValue()).build());
            declarations.addIdent(decl);
            return decl;
        }
    }
    return null;
}

Example 19 with Type

use of com.acgist.snail.pojo.bean.M3u8.Type in project cel-java by projectnessie.

the class FieldDescription method typeDefToType.

public Type typeDefToType() {
    switch(desc.getJavaType()) {
        case MESSAGE:
            String msgType = desc.getMessageType().getFullName();
            Type wk = Checked.CheckedWellKnowns.get(msgType);
            if (wk != null) {
                return wk;
            }
            return Checked.checkedMessageType(msgType);
        case ENUM:
            return Checked.checkedInt;
        case BOOLEAN:
            return Checked.checkedBool;
        case BYTE_STRING:
            return Checked.checkedBytes;
        case DOUBLE:
        case FLOAT:
            return Checked.checkedDouble;
        case INT:
            if (desc.getType() == FieldDescriptor.Type.UINT32 || desc.getType() == FieldDescriptor.Type.FIXED32) {
                return Checked.checkedUint;
            }
            return Checked.checkedInt;
        case LONG:
            if (desc.getType() == FieldDescriptor.Type.UINT64 || desc.getType() == FieldDescriptor.Type.FIXED64) {
                return Checked.checkedUint;
            }
            return Checked.checkedInt;
        case STRING:
            return Checked.checkedString;
    }
    throw new UnsupportedOperationException("Unknown JavaType " + desc.getJavaType());
}

Example 20 with Type

use of com.acgist.snail.pojo.bean.M3u8.Type in project cel-java by projectnessie.

the class Types method internalIsAssignable.

/**
 * internalIsAssignable returns true if t1 is assignable to t2.
 */
static boolean internalIsAssignable(Mapping m, Type t1, Type t2) {
    // Early terminate the call to avoid cases of infinite recursion.
    if (t1.equals(t2)) {
        return true;
    }
    // Process type parameters.
    Kind kind1 = kindOf(t1);
    Kind kind2 = kindOf(t2);
    if (kind2 == Kind.kindTypeParam) {
        Type t2Sub = m.find(t2);
        if (t2Sub != null) {
            // If the types are compatible, pick the more general type and return true
            if (internalIsAssignable(m, t1, t2Sub)) {
                m.add(t2, mostGeneral(t1, t2Sub));
                return true;
            }
            return false;
        }
        if (notReferencedIn(m, t2, t1)) {
            m.add(t2, t1);
            return true;
        }
    }
    if (kind1 == Kind.kindTypeParam) {
        // For the lower type bound, we currently do not perform adjustment. The restricted
        // way we use type parameters in lower type bounds, it is not necessary, but may
        // become if we generalize type unification.
        Type t1Sub = m.find(t1);
        if (t1Sub != null) {
            // If the types are compatible, pick the more general type and return true
            if (internalIsAssignable(m, t1Sub, t2)) {
                m.add(t1, mostGeneral(t1Sub, t2));
                return true;
            }
            return false;
        }
        if (notReferencedIn(m, t1, t2)) {
            m.add(t1, t2);
            return true;
        }
    }
    // Next check for wildcard types.
    if (isDynOrError(t1) || isDynOrError(t2)) {
        return true;
    }
    // Test for when the types do not need to agree, but are more specific than dyn.
    switch(kind1) {
        case kindNull:
            return internalIsAssignableNull(t2);
        case kindPrimitive:
            return internalIsAssignablePrimitive(t1.getPrimitive(), t2);
        case kindWrapper:
            return internalIsAssignable(m, Decls.newPrimitiveType(t1.getWrapper()), t2);
        default:
            if (kind1 != kind2) {
                return false;
            }
    }
    // Test for when the types must agree.
    switch(kind1) {
        // ERROR, TYPE_PARAM, and DYN handled above.
        case kindAbstract:
            return internalIsAssignableAbstractType(m, t1.getAbstractType(), t2.getAbstractType());
        case kindFunction:
            return internalIsAssignableFunction(m, t1.getFunction(), t2.getFunction());
        case kindList:
            return internalIsAssignable(m, t1.getListType().getElemType(), t2.getListType().getElemType());
        case kindMap:
            return internalIsAssignableMap(m, t1.getMapType(), t2.getMapType());
        case kindObject:
            return t1.getMessageType().equals(t2.getMessageType());
        case kindType:
            // type cannot affect method resolution or assignability.
            return true;
        case kindWellKnown:
            return t1.getWellKnown() == t2.getWellKnown();
        default:
            return false;
    }
}