private static boolean checkArrayEquivalent(BType actualType, BType expType) { if (expType.getTag() == TypeTags.ARRAY_TAG && actualType.getTag() == TypeTags.ARRAY_TAG) { // Both types are array types BArrayType lhrArrayType = (BArrayType) expType; BArrayType rhsArrayType = (BArrayType) actualType; return checkArrayEquivalent(lhrArrayType.getElementType(), rhsArrayType.getElementType()); } // Now one or both types are not array types and they have to be equal if (expType == actualType) { return true; } return false; }
private static BType getElementType(BType type) { if (type.getTag() != TypeTags.ARRAY_TAG) { return type; } return getElementType(((BArrayType) type).getElementType()); }
private BType getElementType(BType type) { if (type.getTag() != TypeTags.ARRAY_TAG) { return type; } return getElementType(((BArrayType) type).getElementType()); }
/** * Check the validity of array type in data binding scenario. * * @param entityBodyParam Represents resource parameter details * @return a boolean indicating the validity of the array type */ private boolean validArrayType(ParamDetail entityBodyParam) { return ((BArrayType) entityBodyParam.getVarType()).getElementType().getTag() == TypeTags.BYTE_TAG || ((BArrayType) entityBodyParam.getVarType()).getElementType().getTag() == TypeTags.RECORD_TYPE_TAG; }
private static boolean isDeepStampingRequiredForArray(BType sourceType) { BType elementType = ((BArrayType) sourceType).getElementType(); if (elementType != null) { if (BTypes.isValueType(elementType)) { return false; } else if (elementType instanceof BArrayType) { return isDeepStampingRequiredForArray(elementType); } return true; } return true; }
private void handleMappingArrayElementToNonUnionType(boolean containsNull, BType nonNilType, BNewArray newArray, BMap<String, BValue> bStruct, String fieldName) { if (containsNull) { throw new BallerinaException( "Trying to assign an array containing NULL values to an array of a non-nillable element type"); } else { validateAndSetRefRecordField(bStruct, fieldName, ((BArrayType) nonNilType) .getElementType().getTag(), ((BArrayType) newArray.getType()).getElementType().getTag(), newArray, MISMATCHING_FIELD_ASSIGNMENT); } }
public SerializableBRefArray(BValueArray bRefValueArray, SerializableState state) { BArrayType arrayType = (BArrayType) bRefValueArray.getType(); if (arrayType != null) { structName = arrayType.getElementType().getName(); pkgPath = arrayType.getElementType().getPackagePath(); } for (int i = 0; i < bRefValueArray.size(); i++) { values.add(state.serialize(bRefValueArray.getRefValue(i))); } }
private static boolean checkIsLikeArrayType(BValue sourceValue, BArrayType targetType) { if (!(sourceValue instanceof BValueArray)) { return false; } BValueArray source = (BValueArray) sourceValue; if (BTypes.isValueType(source.elementType)) { return checkIsType(source.elementType, targetType.getElementType(), new ArrayList<>()); } BType arrayElementType = targetType.getElementType(); BRefType<?>[] arrayValues = source.getValues(); for (int i = 0; i < ((BValueArray) sourceValue).size(); i++) { if (!checkIsLikeType(arrayValues[i], arrayElementType)) { return false; } } return true; }
private static boolean checkIsArrayType(BType sourceType, BArrayType targetType, List<TypePair> unresolvedTypes) { if (sourceType.getTag() != TypeTags.ARRAY_TAG) { return false; } BArrayType sourceArrayType = (BArrayType) sourceType; if (sourceArrayType.getState() != targetType.getState() || sourceArrayType.getSize() != targetType.getSize()) { return false; } return checkIsType(sourceArrayType.getElementType(), targetType.getElementType(), unresolvedTypes); }
private void handleMappingArrayElementToUnionType(BArrayType expectedArrayType, BNewArray arrayTobeSet, String fieldName, BMap<String, BValue> bStruct) { BArrayType arrayType = (BArrayType) arrayTobeSet.getType(); if (arrayType.getElementType().getTag() == TypeTags.NULL_TAG) { bStruct.put(fieldName, arrayTobeSet); } else { BUnionType expectedArrayElementUnionType = (BUnionType) expectedArrayType.getElementType(); BType expectedNonNilArrayElementType = retrieveNonNilType(expectedArrayElementUnionType.getMemberTypes()); BType actualNonNilArrayElementType = getActualNonNilArrayElementType(arrayType.getElementType()); validateAndSetRefRecordField(bStruct, fieldName, expectedNonNilArrayElementType .getTag(), actualNonNilArrayElementType.getTag(), arrayTobeSet, UNASSIGNABLE_UNIONTYPE_EXCEPTION); } }
private void assignOIDValue(int fieldTypeTag, BType fieldType, String fieldName, int index, BMap<String, BValue> bStruct, ErrorHandlerFunction errorHandlerFunction) throws SQLException { if (fieldTypeTag == TypeTags.ARRAY_TAG) { int elementTypeTag = ((BArrayType) fieldType).getElementType().getTag(); if (elementTypeTag == TypeTags.BYTE_TAG) { Blob blobValue = rs.getBlob(index); byte[] bytes = blobValue.getBytes(1L, (int) blobValue.length()); bStruct.put(fieldName, bytes == null ? null : new BValueArray(bytes)); } else { errorHandlerFunction.apply(); } } else if (fieldTypeTag == TypeTags.INT_TAG) { bStruct.put(fieldName, new BInteger(rs.getLong(index))); } else { errorHandlerFunction.apply(); } }
return isAnydata(((BTupleType) type).getTupleTypes(), unresolvedTypes); case TypeTags.ARRAY_TAG: return isAnydata(((BArrayType) type).getElementType(), unresolvedTypes); case TypeTags.FINITE_TYPE_TAG: Set<BType> valSpaceTypes = ((BFiniteType) type).valueSpace.stream()
private static boolean checkArrayCast(BType sourceType, BType targetType, List<TypePair> unresolvedTypes) { if (targetType.getTag() == TypeTags.ARRAY_TAG && sourceType.getTag() == TypeTags.ARRAY_TAG) { BArrayType sourceArrayType = (BArrayType) sourceType; BArrayType targetArrayType = (BArrayType) targetType; if (targetArrayType.getDimensions() > sourceArrayType.getDimensions()) { return false; } return checkArrayCast(sourceArrayType.getElementType(), targetArrayType.getElementType(), unresolvedTypes); } else if (targetType.getTag() == TypeTags.UNION_TAG) { return checkUnionAssignable(sourceType, targetType, unresolvedTypes); } if (targetType.getTag() == TypeTags.ANY_TAG) { return true; } return sourceType.equals(targetType); }
@Override public void execute(Context context) { BValue entityBody = context.getRefArgument(0); Checksum checksum = new CRC32(); byte[] bytes; long checksumVal; BType argType = entityBody.getType(); if (argType == BTypes.typeJSON || argType == BTypes.typeXML || argType == BTypes.typeString) { // TODO: Look at the possibility of making the encoding configurable bytes = entityBody.stringValue().getBytes(StandardCharsets.UTF_8); } else if (argType.getTag() == TypeTags.ARRAY_TAG && ((BArrayType) argType).getElementType().getTag() == TypeTags.BYTE_TAG) { bytes = ((BValueArray) entityBody).getBytes(); } else { throw new BallerinaException( "failed to generate hash: unsupported data type: " + entityBody.getType().getName()); } checksum.update(bytes, 0, bytes.length); checksumVal = checksum.getValue(); context.setReturnValues(new BString(Long.toHexString(checksumVal))); } }
private void handleMappingArrayValue(BType nonNilType, BMap<String, BValue> bStruct, BNewArray dataArray, String fieldName, boolean containsNull) { if (nonNilType.getTag() == TypeTags.ARRAY_TAG) { BArrayType expectedArrayType = (BArrayType) nonNilType; if (((BArrayType) nonNilType).getElementType().getTag() == TypeTags.UNION_TAG) { handleMappingArrayElementToUnionType(expectedArrayType, dataArray, fieldName, bStruct); } else { handleMappingArrayElementToNonUnionType(containsNull, nonNilType, dataArray, bStruct, fieldName); } } else { handleMismatchingFieldAssignment(); } }
public boolean equals(Object obj) { // if obj == 'null' or not instance of BTypeValue - return false if (obj == null || !(obj instanceof BTypeDescValue)) { return false; } BTypeDescValue typeValue = (BTypeDescValue) obj; if ((typeValue.value() instanceof BArrayType) && (this.value() instanceof BArrayType)) { BArrayType objArrayType = (BArrayType) typeValue.value(); BArrayType thisArrayType = (BArrayType) this.value(); if (objArrayType.getDimensions() != thisArrayType.getDimensions()) { return false; } return (new BTypeDescValue(thisArrayType.getElementType())) .equals(new BTypeDescValue(objArrayType.getElementType())); } else { return typeValue.value() == this.value(); } }
@Override public BPacket toBValue(BArrayType type, BValueSerializer serializer) { BType elementType = type.getElementType(); int dimensions = type.getDimensions(); int size = type.getSize(); BPacket packet = BPacket.from(typeName(), null); packet.put(ELEM_TYPE, serializer.toBValue(elementType, null)); packet.put(DIMENSIONS, new BInteger(dimensions)); packet.put(SIZE, new BInteger(size)); return packet; }
public static boolean isAssignable(BType sourceType, BType targetType, List<TypePair> unresolvedTypes) { if (isSameOrAnyType(sourceType, targetType)) { return true; } if (targetType.getTag() == TypeTags.UNION_TAG) { return checkUnionAssignable(sourceType, targetType, unresolvedTypes); } // TODO: 6/26/18 complete impl. for JSON assignable if (targetType.getTag() == TypeTags.JSON_TAG && sourceType.getTag() == TypeTags.JSON_TAG) { return true; } if (targetType.getTag() == TypeTags.ARRAY_TAG && sourceType.getTag() == TypeTags.ARRAY_TAG) { if (((BArrayType) sourceType).getState() == BArrayState.CLOSED_SEALED && ((BArrayType) targetType).getState() == BArrayState.CLOSED_SEALED && ((BArrayType) sourceType).getSize() != ((BArrayType) targetType).getSize()) { return false; } return checkArrayCast(((BArrayType) sourceType).getElementType(), ((BArrayType) targetType).getElementType(), unresolvedTypes); } if (sourceType.getTag() == TypeTags.TUPLE_TAG && targetType.getTag() == TypeTags.TUPLE_TAG) { return checkTupleAssignable(sourceType, targetType, unresolvedTypes); } return checkCastByType(sourceType, targetType, unresolvedTypes); }
private void handleArrayValue(BMap<String, BValue> bStruct, String fieldName, Array data, BType fieldType) throws SQLException { int fieldTypeTag = fieldType.getTag(); BNewArray dataArray = getDataArray(data); if (dataArray != null) { BType nonNilType = fieldType; if (fieldTypeTag == TypeTags.UNION_TAG) { nonNilType = retrieveNonNilType(((BUnionType) fieldType).getMemberTypes()); } // The dataArray is created from the array returned from the database. There, an array of Union Type is // created only if the array includes NULL elements. boolean containsNull = dataArray.getType().getTag() == TypeTags.ARRAY_TAG && ((BArrayType) dataArray.getType()).getElementType().getTag() == TypeTags.UNION_TAG; handleMappingArrayValue(nonNilType, bStruct, dataArray, fieldName, containsNull); } else { if (fieldTypeTag == TypeTags.UNION_TAG) { bStruct.put(fieldName, null); } else { handleNilToNonNillableFieldAssignment(); } } }
public static void execListAddOperation(BNewArray array, long index, BRefType refType) { if (array.getType().getTag() != TypeTags.ARRAY_TAG) { BValueArray bRefValueArray = (BValueArray) array; bRefValueArray.add(index, refType); return; } BValueArray bValueArray = (BValueArray) array; switch (((BArrayType) array.getType()).getElementType().getTag()) { case TypeTags.BOOLEAN_TAG: bValueArray.add(index, ((BBoolean) refType).value() ? 1 : 0); return; case TypeTags.BYTE_TAG: bValueArray.add(index, (byte) refType.value()); return; case TypeTags.FLOAT_TAG: bValueArray.add(index, (double) refType.value()); return; case TypeTags.INT_TAG: bValueArray.add(index, (long) refType.value()); return; case TypeTags.STRING_TAG: bValueArray.add(index, (String) refType.value()); return; default: bValueArray.add(index, refType); } } }