mirror of
https://github.com/KevinMidboe/linguist.git
synced 2025-10-29 17:50:22 +00:00
458 lines
16 KiB
OpenEdge ABL
458 lines
16 KiB
OpenEdge ABL
/* ============================================================
|
|
* This code is part of the "apex-lang" open source project avaiable at:
|
|
*
|
|
* http://code.google.com/p/apex-lang/
|
|
*
|
|
* This code is licensed under the Apache License, Version 2.0. You may obtain a
|
|
* copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
* ============================================================
|
|
*/
|
|
global class ArrayUtils {
|
|
|
|
global static String[] EMPTY_STRING_ARRAY = new String[]{};
|
|
global static Integer MAX_NUMBER_OF_ELEMENTS_IN_LIST {get{return 1000;}}
|
|
|
|
global static List<String> objectToString(List<Object> objects){
|
|
List<String> strings = null;
|
|
if(objects != null){
|
|
strings = new List<String>();
|
|
if(objects.size() > 0){
|
|
for(Object obj : objects){
|
|
if(obj instanceof String){
|
|
strings.add((String)obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return strings;
|
|
}
|
|
|
|
global static Object[] reverse(Object[] anArray) {
|
|
if (anArray == null) {
|
|
return null;
|
|
}
|
|
Integer i = 0;
|
|
Integer j = anArray.size() - 1;
|
|
Object tmp;
|
|
while (j > i) {
|
|
tmp = anArray[j];
|
|
anArray[j] = anArray[i];
|
|
anArray[i] = tmp;
|
|
j--;
|
|
i++;
|
|
}
|
|
return anArray;
|
|
}
|
|
|
|
global static SObject[] reverse(SObject[] anArray) {
|
|
if (anArray == null) {
|
|
return null;
|
|
}
|
|
Integer i = 0;
|
|
Integer j = anArray.size() - 1;
|
|
SObject tmp;
|
|
while (j > i) {
|
|
tmp = anArray[j];
|
|
anArray[j] = anArray[i];
|
|
anArray[i] = tmp;
|
|
j--;
|
|
i++;
|
|
}
|
|
return anArray;
|
|
}
|
|
|
|
global static List<String> lowerCase(List<String> strs){
|
|
List<String> returnValue = null;
|
|
if(strs != null){
|
|
returnValue = new List<String>();
|
|
if(strs.size() > 0){
|
|
for(String str : strs){
|
|
returnValue.add(str == null ? null : str.toLowerCase());
|
|
}
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
global static List<String> upperCase(List<String> strs){
|
|
List<String> returnValue = null;
|
|
if(strs != null){
|
|
returnValue = new List<String>();
|
|
if(strs.size() > 0){
|
|
for(String str : strs){
|
|
returnValue.add(str == null ? null : str.toUpperCase());
|
|
}
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
global static List<String> trim(List<String> strs){
|
|
List<String> returnValue = null;
|
|
if(strs != null){
|
|
returnValue = new List<String>();
|
|
if(strs.size() > 0){
|
|
for(String str : strs){
|
|
returnValue.add(str == null ? null : str.trim());
|
|
}
|
|
}
|
|
}
|
|
return returnValue;
|
|
}
|
|
|
|
global static Object[] mergex(Object[] array1, Object[] array2){
|
|
if(array1 == null){ return array2; }
|
|
if(array2 == null){ return array1; }
|
|
Object[] merged = new Object[array1.size() + array2.size()];
|
|
for(Integer i = 0; i < array1.size(); i++){
|
|
merged[i] = array1[i];
|
|
}
|
|
for(Integer i = 0; i < array2.size(); i++){
|
|
merged[i+array1.size()] = array2[i];
|
|
}
|
|
return merged;
|
|
}
|
|
|
|
global static SObject[] mergex(SObject[] array1, SObject[] array2){
|
|
if(array1 == null){ return array2; }
|
|
if(array2 == null){ return array1; }
|
|
if(array1.size() <= 0){ return array2; }
|
|
List<SObject> merged = new List<SObject>();
|
|
for(SObject sObj : array1){ merged.add(sObj); }
|
|
for(SObject sObj : array2){ merged.add(sObj); }
|
|
return merged;
|
|
}
|
|
|
|
global static Boolean isEmpty(Object[] objectArray){
|
|
if(objectArray == null){
|
|
return true;
|
|
}
|
|
return objectArray.size() == 0;
|
|
}
|
|
|
|
global static Boolean isEmpty(SObject[] objectArray){
|
|
if(objectArray == null){
|
|
return true;
|
|
}
|
|
return objectArray.size() == 0;
|
|
}
|
|
|
|
global static Boolean isNotEmpty(Object[] objectArray){
|
|
return !isEmpty(objectArray);
|
|
}
|
|
|
|
global static Boolean isNotEmpty(SObject[] objectArray){
|
|
return !isEmpty(objectArray);
|
|
}
|
|
|
|
global static Object[] pluck(SObject[] objectArray, String fieldName){
|
|
if(isEmpty(objectArray) || fieldName == null || fieldName.trim() == null || fieldName.trim().length() == 0){
|
|
return new Object[]{};
|
|
}
|
|
Object[] plucked = new Object[objectArray.size()];
|
|
for(Integer i = 0; i < objectArray.size(); i++){
|
|
plucked[i] = objectArray[i].get(fieldName);
|
|
}
|
|
return plucked;
|
|
}
|
|
|
|
|
|
global static String toString(Object[] objectArray){
|
|
if(objectArray == null){
|
|
return 'null';
|
|
}
|
|
String returnValue = '{';
|
|
for(Integer i = 0; i < objectArray.size(); i++){
|
|
if(i!=0){ returnValue += ','; }
|
|
returnValue += '\'' + objectArray[i] + '\'';
|
|
}
|
|
returnValue += '}';
|
|
return returnValue;
|
|
}
|
|
|
|
global static String toString(SObject[] objectArray){
|
|
if(objectArray == null){
|
|
return 'null';
|
|
}
|
|
String returnValue = '{';
|
|
for(Integer i = 0; i < objectArray.size(); i++){
|
|
if(i!=0){ returnValue += ','; }
|
|
returnValue += '\'' + objectArray[i] + '\'';
|
|
}
|
|
returnValue += '}';
|
|
return returnValue;
|
|
}
|
|
|
|
global static void assertArraysAreEqual(Object[] expected, Object[] actual){
|
|
//check to see if one param is null but the other is not
|
|
System.assert((expected == null && actual == null)|| (expected != null && actual != null),
|
|
'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
if(expected != null && actual != null){
|
|
System.assert(expected.size() == actual.size(), 'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
for(Integer i = 0; i < expected.size(); i++){
|
|
System.assert(expected[i] == actual[i], 'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
}
|
|
}
|
|
}
|
|
|
|
global static void assertArraysAreEqual(SObject[] expected, SObject[] actual){
|
|
//check to see if one param is null but the other is not
|
|
System.assert((expected == null && actual == null)|| (expected != null && actual != null),
|
|
'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
if(expected != null && actual != null){
|
|
System.assert(expected.size() == actual.size(), 'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
for(Integer i = 0; i < expected.size(); i++){
|
|
System.assert(expected[i] == actual[i], 'Assertion failed, the following two arrays are not equal. Expected: '
|
|
+ ArrayUtils.toString(expected) + ', Actual: ' + ArrayUtils.toString(actual));
|
|
}
|
|
}
|
|
}
|
|
|
|
global static List<Object> merg(List<Object> list1, List<Object> list2) {
|
|
List<Object> returnList = new List<Object>();
|
|
if(list1 != null && list2 != null && (list1.size()+list2.size()) > MAX_NUMBER_OF_ELEMENTS_IN_LIST){
|
|
throw new IllegalArgumentException('Lists cannot be merged because new list would be greater than maximum number of elements in a list: ' + MAX_NUMBER_OF_ELEMENTS_IN_LIST);
|
|
}
|
|
if(isNotEmpty(list1)){
|
|
for(Object elmt : list1){
|
|
returnList.add(elmt);
|
|
}
|
|
}
|
|
if(isNotEmpty(list2)){
|
|
for(Object elmt : list2){
|
|
returnList.add(elmt);
|
|
}
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
|
|
global static List<SObject> merg(List<SObject> list1, List<SObject> list2) {
|
|
if(list1 != null && list2 != null && (list1.size()+list2.size()) > MAX_NUMBER_OF_ELEMENTS_IN_LIST){
|
|
throw new IllegalArgumentException('Lists cannot be merged because new list would be greater than maximum number of elements in a list: ' + MAX_NUMBER_OF_ELEMENTS_IN_LIST);
|
|
}
|
|
if(isEmpty(list1) && isEmpty(list2)){
|
|
return null;
|
|
}
|
|
List<SObject> returnList = new List<SObject>();
|
|
if(list1 != null){
|
|
for(SObject elmt : list1){
|
|
returnList.add(elmt);
|
|
}
|
|
}
|
|
if(list2 != null){
|
|
for(SObject elmt : list2){
|
|
returnList.add(elmt);
|
|
}
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
global static List<Object> subset(List<Object> aList, Integer count) {
|
|
return subset(aList,0,count);
|
|
}
|
|
|
|
global static List<Object> subset(List<Object> list1, Integer startIndex, Integer count) {
|
|
List<Object> returnList = new List<Object>();
|
|
if(list1 != null && list1.size() > 0 && startIndex >= 0 && startIndex <= list1.size()-1 && count > 0){
|
|
for(Integer i = startIndex; i < list1.size() && i - startIndex < count; i++){
|
|
returnList.add(list1.get(i));
|
|
}
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
|
|
global static List<SObject> subset(List<SObject> aList, Integer count) {
|
|
return subset(aList,0,count);
|
|
}
|
|
|
|
global static List<SObject> subset(List<SObject> list1, Integer startIndex, Integer count) {
|
|
List<SObject> returnList = null;
|
|
if(list1 != null && list1.size() > 0 && startIndex <= list1.size()-1 && count > 0){
|
|
returnList = new List<SObject>();
|
|
for(Integer i = startIndex; i < list1.size() && i - startIndex < count; i++){
|
|
returnList.add(list1.get(i));
|
|
}
|
|
}
|
|
return returnList;
|
|
}
|
|
|
|
//===============================================
|
|
//LIST/ARRAY SORTING
|
|
//===============================================
|
|
|
|
//FOR FORCE.COM PRIMITIVES (Double,Integer,ID,etc.):
|
|
global static List<Object> qsort(List<Object> theList) {
|
|
return qsort(theList,new PrimitiveComparator());
|
|
}
|
|
|
|
global static List<Object> qsort(List<Object> theList, Boolean sortAsc) {
|
|
return qsort(theList,new PrimitiveComparator(),sortAsc);
|
|
}
|
|
|
|
global static List<Object> qsort(List<Object> theList, ObjectComparator comparator) {
|
|
return qsort(theList,comparator,true);
|
|
}
|
|
|
|
global static List<Object> qsort(List<Object> theList, ObjectComparator comparator, Boolean sortAsc) {
|
|
return qsort(theList, 0, (theList == null ? 0 : theList.size()-1),comparator,sortAsc);
|
|
}
|
|
|
|
|
|
|
|
//FOR SALESFORCE OBJECTS (sObjects):
|
|
global static List<SObject> qsort(List<SObject> theList, ISObjectComparator comparator) {
|
|
return qsort(theList,comparator,true);
|
|
}
|
|
|
|
global static List<SObject> qsort(List<SObject> theList, ISObjectComparator comparator,Boolean sortAsc ) {
|
|
return qsort(theList, 0, (theList == null ? 0 : theList.size()-1),comparator,sortAsc);
|
|
}
|
|
|
|
private static List<Object> qsort(List<Object> theList,
|
|
Integer lo0,
|
|
Integer hi0,
|
|
ObjectComparator comparator,
|
|
Boolean sortAsc){
|
|
Integer lo = lo0;
|
|
Integer hi = hi0;
|
|
|
|
if (lo >= hi) {
|
|
return theList;
|
|
} else if( lo == hi - 1 ) {
|
|
|
|
if (( comparator.compare(theList[lo],theList[hi])>0 && sortAsc) ||
|
|
(comparator.compare(theList[lo],theList[hi])<0 && !sortAsc)
|
|
) {
|
|
Object prs = theList[lo];
|
|
theList[lo] = theList[hi];
|
|
theList[hi] = prs;
|
|
}
|
|
return theList;
|
|
}
|
|
|
|
Object pivot = theList[(lo + hi) / 2];
|
|
theList[(lo + hi) / 2] = theList[hi];
|
|
theList[hi] = pivot;
|
|
|
|
while( lo < hi ) {
|
|
while ((comparator.compare(theList[lo], pivot)<=0 && lo < hi && sortAsc) ||
|
|
(comparator.compare(theList[lo], pivot)>=0 && lo < hi && !sortAsc)
|
|
) { lo++; }
|
|
while (( comparator.compare(pivot,theList[hi])<=0 && lo < hi && sortAsc) ||
|
|
( comparator.compare(pivot,theList[hi])>=0 && lo < hi && !sortAsc)
|
|
) { hi--; }
|
|
|
|
if( lo < hi ){
|
|
Object prs = theList[lo];
|
|
theList[lo] = theList[hi];
|
|
theList[hi] = prs;
|
|
}
|
|
}
|
|
|
|
theList[hi0] = theList[hi];
|
|
theList[hi] = pivot;
|
|
|
|
qsort(theList, lo0, lo-1,comparator,sortAsc);
|
|
qsort(theList, hi+1, hi0,comparator,sortAsc);
|
|
return theList;
|
|
}
|
|
|
|
|
|
private static List<SObject> qsort(List<SObject> theList,
|
|
Integer lo0,
|
|
Integer hi0,
|
|
ISObjectComparator comparator,
|
|
Boolean sortAsc){
|
|
Integer lo = lo0;
|
|
Integer hi = hi0;
|
|
|
|
if (lo >= hi) {
|
|
return theList;
|
|
} else if( lo == hi - 1 ) {
|
|
|
|
if (( comparator.compare(theList[lo],theList[hi])>0 && sortAsc) ||
|
|
(comparator.compare(theList[lo],theList[hi])<0 && !sortAsc)
|
|
) {
|
|
SObject prs = theList[lo];
|
|
theList[lo] = theList[hi];
|
|
theList[hi] = prs;
|
|
}
|
|
return theList;
|
|
}
|
|
|
|
SObject pivot = theList[(lo + hi) / 2];
|
|
theList[(lo + hi) / 2] = theList[hi];
|
|
theList[hi] = pivot;
|
|
|
|
while( lo < hi ) {
|
|
while ((comparator.compare(theList[lo], pivot)<=0 && lo < hi && sortAsc) ||
|
|
(comparator.compare(theList[lo], pivot)>=0 && lo < hi && !sortAsc)
|
|
) { lo++; }
|
|
while (( comparator.compare(pivot,theList[hi])<=0 && lo < hi && sortAsc) ||
|
|
( comparator.compare(pivot,theList[hi])>=0 && lo < hi && !sortAsc)
|
|
) { hi--; }
|
|
|
|
if( lo < hi ){
|
|
SObject prs = theList[lo];
|
|
theList[lo] = theList[hi];
|
|
theList[hi] = prs;
|
|
}
|
|
}
|
|
|
|
theList[hi0] = theList[hi];
|
|
theList[hi] = pivot;
|
|
|
|
qsort(theList, lo0, lo-1,comparator,sortAsc);
|
|
qsort(theList, hi+1, hi0,comparator,sortAsc);
|
|
return theList;
|
|
}
|
|
/*
|
|
global static List<Object> unique(List<Object> theList) {
|
|
List<Object> uniques = new List<Object>();
|
|
Set<Object> keys = new Set<Object>();
|
|
if(theList != null && theList.size() > 0){
|
|
for(Object obj : theList){
|
|
if(keys.contains(obj)){
|
|
continue;
|
|
} else {
|
|
keys.add(obj);
|
|
uniques.add(obj);
|
|
}
|
|
}
|
|
}
|
|
return uniques;
|
|
}
|
|
|
|
global static List<SObject> unique(List<SObject> theList) {
|
|
if(theList == null){
|
|
return null;
|
|
}
|
|
List<SObject> uniques = createEmptySObjectList(theList.get(0));
|
|
Set<String> keys = new Set<String>();
|
|
if(theList != null && theList.size() > 0){
|
|
String key = null;
|
|
for(SObject obj : theList){
|
|
key = obj == null ? null : ''+obj;
|
|
if(keys.contains(key)){
|
|
continue;
|
|
} else {
|
|
keys.add(key);
|
|
uniques.add(obj);
|
|
}
|
|
}
|
|
}
|
|
return uniques;
|
|
}
|
|
*/
|
|
|
|
|
|
} |