/** * Deep equality check for an array/tuple. * * @param lhsList The array/tuple on the left hand side * @param rhsList The array/tuple on the right hand side * @param checkedValues Structured value pairs already compared or being compared * @return True if the array/tuple values are equal, else false. */ private static boolean isEqual(BNewArray lhsList, BNewArray rhsList, List<ValuePair> checkedValues) { ValuePair compValuePair = new ValuePair(lhsList, rhsList); if (checkedValues.contains(compValuePair)) { return true; } checkedValues.add(compValuePair); if (lhsList.size() != rhsList.size()) { return false; } for (int i = 0; i < lhsList.size(); i++) { if (!isEqual(lhsList.getBValue(i), rhsList.getBValue(i), checkedValues)) { return false; } } return true; }
private static void convertArrayToJSON(Strand ctx, int[] operands, StackFrame sf) { int i = operands[0]; int j = operands[1]; BNewArray bArray = (BNewArray) sf.refRegs[i]; try { sf.refRegs[j] = JSONUtils.convertArrayToJSON(bArray); } catch (Exception e) { String errorMsg = "cannot convert '" + bArray.getType() + "' to type '" + BTypes.typeJSON + "': " + e.getMessage(); handleTypeConversionError(ctx, sf, j, errorMsg); } }
protected void prepareForAdd(long index, int currentArraySize) { int intIndex = (int) index; rangeCheck(index, size); ensureCapacity(intIndex + 1, currentArraySize); resetSize(intIndex); }
BArrayIterator(BNewArray value) { this.array = value; this.length = value.size(); }
private String getStringValue(BValue bValue) { String bValueString; if (bValue == null) { bValueString = null; } else if (bValue instanceof BValueType || bValue instanceof BXML || bValue.getType().getTag() == TypeTags.JSON) { bValueString = bValue.stringValue(); } else if (bValue instanceof BNewArray) { BNewArray bArray = (BNewArray) bValue; bValueString = "Array[" + bArray.size() + "] "; bValueString = bValueString + bArray.stringValue(); } else if (bValue.getType().getTag() == TypeTags.MAP) { BMap bmap = (BMap) bValue; bValueString = "Map[" + bmap.size() + "] "; bValueString = bValueString + bmap.stringValue(); } else if (bValue.getType().getTag() == TypeTags.RECORD) { bValueString = "Record " + bValue.getType().getName() + " "; bValueString = bValueString + bValue.stringValue(); } else if (bValue.getType().getTag() == TypeTags.OBJECT) { bValueString = "Object " + bValue.getType().getName() + " "; bValueString = bValueString + ((BMap) bValue).absoluteStringValue(); } else { bValueString = "<Complex_Value>"; } return bValueString; }
@Override public BValue getNext() { long cursor = this.cursor++; if (cursor == length) { return null; } return array.getBValue(cursor); }
protected void ensureCapacity(int requestedCapacity, int currentArraySize) { if ((requestedCapacity) - currentArraySize >= 0) { // Here the growth rate is 1.5. This value has been used by many other languages int newArraySize = currentArraySize + (currentArraySize >> 1); // Now get the maximum value of the calculate new array size and request capacity newArraySize = Math.max(newArraySize, requestedCapacity); // Now get the minimum value of new array size and maximum array size newArraySize = Math.min(newArraySize, maxArraySize); grow(newArraySize); } }
protected void rangeCheckForGet(long index, int size) { rangeCheck(index, size); if (index < 0 || index >= size) { throw BLangExceptionHelper.getRuntimeException(BallerinaErrorReasons.INDEX_OUT_OF_RANGE_ERROR, RuntimeErrors.ARRAY_INDEX_OUT_OF_RANGE, index, size); } }
@Override public Value[] getArrayField(String fieldName) { final BNewArray refField = (BNewArray) value.get(fieldName); if (refField == null) { return null; } List<Value> list = new ArrayList<>(); final BIterator bIterator = refField.newIterator(); while (bIterator.hasNext()) { list.add(ValueImpl.createValue(bIterator.getNext())); } return list.toArray(new Value[0]); }
return; } else if (entity instanceof BNewArray) { sf.longRegs[j] = ((BNewArray) entity).size(); return;
/** * Extract function arguments from the values sets. * @param valueSets user provided value sets * @return a list of function arguments */ private List<BValue[]> extractArguments(BValue[] valueSets) { List<BValue[]> argsList = new ArrayList<>(); for (BValue value : valueSets) { if (value instanceof BValueArray) { BValueArray array = (BValueArray) value; for (BIterator it = array.newIterator(); it.hasNext(); ) { BValue vals = it.getNext(); if (vals instanceof BNewArray) { BNewArray bNewArray = (BNewArray) vals; BValue[] args = new BValue[(int) bNewArray.size()]; for (int j = 0; j < bNewArray.size(); j++) { args[j] = bNewArray.getBValue(j); } argsList.add(args); } else { // cannot happen due to validations done at annotation processor } } } else { argsList.add(new BValue[]{value}); } } return argsList; }
&& ((BArrayType) value.getType()).getElementType().getTag() != TypeTags.BYTE_TAG) && !Constants.SQLDataTypes.ARRAY.equalsIgnoreCase(sqlType)) { count = (int) ((BNewArray) value).size(); } else { count = 1;
case TypeTags.ARRAY_TAG: BNewArray arr = (BNewArray) sourceValue; switch (arr.getType().getTag()) { case TypeTags.INT_TAG: case TypeTags.FLOAT_TAG:
&& ((BArrayType) value.getType()).getElementType().getTag() != TypeTags.BYTE_TAG) && !Constants.SQLDataTypes.ARRAY.equalsIgnoreCase(sqlType)) { int arrayLength = (int) ((BNewArray) value).size(); int typeTagOfArrayElement = ((BArrayType) value.getType()).getElementType().getTag(); for (int i = 0; i < arrayLength; i++) {
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); } }
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(); } } }
/** * Convert {@link BNewArray} to JSON. * * @param bArray {@link BNewArray} to be converted to JSON * @return JSON representation of the provided bArray */ public static BValueArray convertArrayToJSON(BNewArray bArray) { if (bArray instanceof BDecimalArray) { return convertArrayToJSON(bArray); } else if (bArray instanceof BValueArray) { if (((BValueArray) bArray).elementType == BTypes.typeInt) { return convertIntArrayToJSON((BValueArray) bArray); } else if (((BValueArray) bArray).elementType == BTypes.typeBoolean) { return convertBooleanArrayToJSON((BValueArray) bArray); } else if (((BValueArray) bArray).elementType == BTypes.typeFloat) { return convertFloatArrayToJSON((BValueArray) bArray); } else if (((BValueArray) bArray).elementType == BTypes.typeString) { return convertStringArrayToJSON((BValueArray) bArray); } else { return convertRefArrayToJSON((BValueArray) bArray); } } throw BLangExceptionHelper.getRuntimeException(RuntimeErrors.INCOMPATIBLE_TYPE, BTypes.typeJSON, bArray.getType()); }
public static BRefType<?> execListGetOperation(BNewArray array, long index) { if (array.getType().getTag() != TypeTags.ARRAY_TAG) { BValueArray bRefValueArray = (BValueArray) array; return bRefValueArray.getRefValue(index); } switch (((BArrayType) array.getType()).getElementType().getTag()) { case TypeTags.BOOLEAN_TAG: BValueArray bBooleanArray = (BValueArray) array; int i = bBooleanArray.getBoolean(index); return i == 0 ? new BBoolean(false) : new BBoolean(true); case TypeTags.BYTE_TAG: BValueArray bByteArray = (BValueArray) array; return new BByte(bByteArray.getByte(index)); case TypeTags.FLOAT_TAG: BValueArray bFloatArray = (BValueArray) array; return new BFloat(bFloatArray.getFloat(index)); case TypeTags.DECIMAL_TAG: BValueArray bDecimalArray = (BValueArray) array; return new BDecimal(new BigDecimal(bDecimalArray.getRefValue(index).stringValue())); case TypeTags.INT_TAG: BValueArray bIntArray = (BValueArray) array; return new BInteger(bIntArray.getInt(index)); case TypeTags.STRING_TAG: BValueArray bStringArray = (BValueArray) array; return new BString(bStringArray.getString(index)); default: BValueArray bRefValueArray = (BValueArray) array; return bRefValueArray.getRefValue(index); } }
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); } } }
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); } }