Rename samples subdirectories

1 files changed, 458 insertions, 0 deletions

diff --git a/samples/Apex/ArrayUtils.cls b/samples/Apex/ArrayUtils.cls
new file mode 100644
index 0000000..b08cd51
--- /dev/null
+++ b/samples/Apex/ArrayUtils.cls
@@ -0,0 +1,458 @@
+/* ============================================================
+ * 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;
+    }
+*/
+
+
+}
\ No newline at end of file