/* * Holds procs to help with list operations * Contains groups: * Misc * Sorting */ /* * Misc */ // Generic listoflist safe add and removal macros: ///If value is a list, wrap it in a list so it can be used with list add/remove operations #define LIST_VALUE_WRAP_LISTS(value) (islist(value) ? list(value) : value) ///Add an untyped item to a list, taking care to handle list items by wrapping them in a list to remove the footgun #define UNTYPED_LIST_ADD(list, item) (list += LIST_VALUE_WRAP_LISTS(item)) ///Remove an untyped item to a list, taking care to handle list items by wrapping them in a list to remove the footgun #define UNTYPED_LIST_REMOVE(list, item) (list -= LIST_VALUE_WRAP_LISTS(item)) #define LAZYINITLIST(L) if (!L) { L = list(); } #define UNSETEMPTY(L) if (L && !length(L)) L = null ///Like LAZYCOPY - copies an input list if the list has entries, If it doesn't the assigned list is nulled #define LAZYLISTDUPLICATE(L) (L ? L.Copy() : null ) #define LAZYREMOVE(L, I) if(L) { L -= I; if(!length(L)) { L = null; } } //ambition start #define LAZYCUT(L, S, E) if((length(L) >= S) && (E == 0 || length(L) >= (E - 1))) { L.Cut(S, E); if(!length(L)) { L = null; } } //ambition end #define LAZYADD(L, I) if(!L) { L = list(); } L += I; #define LAZYOR(L, I) if(!L) { L = list(); } L |= I; #define LAZYFIND(L, V) (L ? L.Find(V) : 0) ///returns L[I] if L exists and I is a valid index of L, runtimes if L is not a list #define LAZYACCESS(L, I) (L ? (isnum(I) ? (I > 0 && I <= length(L) ? L[I] : null) : L[I]) : null) #define LAZYSET(L, K, V) if(!L) { L = list(); } L[K] = V; #define LAZYLEN(L) length(L) ///This is used to add onto lazy assoc list when the value you're adding is a /list/. This one has extra safety over lazyaddassoc because the value could be null (and thus cant be used to += objects) #define LAZYADDASSOCLIST(L, K, V) if(!L) { L = list(); } L[K] += list(V); //Sets a list to null #define LAZYNULL(L) L = null #define LAZYADDASSOC_TG(L, K, V) if(!L) { L = list(); } L[K] += V; ///This is used to add onto lazy assoc list when the value you're adding is a /list/. This one has extra safety over lazyaddassoc because the value could be null (and thus cant be used to += objects) #define LAZYADDASSOC(L, K, V) if(!L) { L = list(); } L[K] += list(V); #define LAZYREMOVEASSOC(L, K, V) if(L) { if(L[K]) { L[K] -= V; if(!length(L[K])) L -= K; } if(!length(L)) L = null; } #define LAZYACCESSASSOC(L, I, K) L ? L[I] ? L[I][K] ? L[I][K] : null : null : null #define QDEL_LAZYLIST(L) for(var/I in L) qdel(I); L = null; //These methods don't null the list #define LAZYCOPY(L) (L ? L.Copy() : list() ) //Use LAZYLISTDUPLICATE instead if you want it to null with no entries #define LAZYCLEARLIST(L) if(L) L.Cut() // Consider LAZYNULL instead #define SANITIZE_LIST(L) ( islist(L) ? L : list() ) #define reverseList(L) reverseRange(L.Copy()) /// Performs an insertion on the given lazy list with the given key and value. If the value already exists, a new one will not be made. #define LAZYORASSOCLIST(lazy_list, key, value) \ LAZYINITLIST(lazy_list); \ LAZYINITLIST(lazy_list[key]); \ lazy_list[key] |= value; /// Passed into BINARY_INSERT to compare keys #define COMPARE_KEY __BIN_LIST[__BIN_MID] /// Passed into BINARY_INSERT to compare values #define COMPARE_VALUE __BIN_LIST[__BIN_LIST[__BIN_MID]] /**** * Binary search sorted insert * INPUT: Object to be inserted * LIST: List to insert object into * TYPECONT: The typepath of the contents of the list * COMPARE: The object to compare against, usualy the same as INPUT * COMPARISON: The variable on the objects to compare * COMPTYPE: How should the values be compared? Either COMPARE_KEY or COMPARE_VALUE. */ #define BINARY_INSERT(INPUT, LIST, TYPECONT, COMPARE, COMPARISON, COMPTYPE) \ do {\ var/list/__BIN_LIST = LIST;\ var/__BIN_CTTL = length(__BIN_LIST);\ if(!__BIN_CTTL) {\ __BIN_LIST += INPUT;\ } else {\ var/__BIN_LEFT = 1;\ var/__BIN_RIGHT = __BIN_CTTL;\ var/__BIN_MID = (__BIN_LEFT + __BIN_RIGHT) >> 1;\ var ##TYPECONT/__BIN_ITEM;\ while(__BIN_LEFT < __BIN_RIGHT) {\ __BIN_ITEM = COMPTYPE;\ if(__BIN_ITEM.##COMPARISON <= COMPARE.##COMPARISON) {\ __BIN_LEFT = __BIN_MID + 1;\ } else {\ __BIN_RIGHT = __BIN_MID;\ };\ __BIN_MID = (__BIN_LEFT + __BIN_RIGHT) >> 1;\ };\ __BIN_ITEM = COMPTYPE;\ __BIN_MID = __BIN_ITEM.##COMPARISON > COMPARE.##COMPARISON ? __BIN_MID : __BIN_MID + 1;\ __BIN_LIST.Insert(__BIN_MID, INPUT);\ };\ } while(FALSE) //Returns a list in plain english as a string /proc/english_list(list/input, nothing_text = "nothing", and_text = " and ", comma_text = ", ", final_comma_text = "" ) var/total = length(input) switch(total) if (0) return "[nothing_text]" if (1) return "[input[1]]" if (2) return "[input[1]][and_text][input[2]]" else var/output = "" var/index = 1 while (index < total) if (index == total - 1) comma_text = final_comma_text output += "[input[index]][comma_text]" index++ return "[output][and_text][input[index]]" /** * English_list but associative supporting. Higher overhead. * @depricated */ /proc/english_list_assoc(list/input, nothing_text = "nothing", and_text = " and ", comma_text = ", ", final_comma_text = "") var/total = length(input) switch(total) if (0) return "[nothing_text]" if (1) var/assoc = input[input[1]] == null? "" : " = [input[input[1]]]" return "[input[1]][assoc]" if (2) var/assoc = input[input[1]] == null? "" : " = [input[input[1]]]" var/assoc2 = input[input[2]] == null? "" : " = [input[input[2]]]" return "[input[1]][assoc][and_text][input[2]][assoc2]" else var/output = "" var/index = 1 var/assoc while (index < total) if (index == total - 1) comma_text = final_comma_text assoc = input[input[index]] == null? "" : " = [input[input[index]]]" output += "[input[index]][assoc][comma_text]" ++index assoc = input[input[index]] == null? "" : " = [input[input[index]]]" return "[output][and_text][input[index]]" //Returns list element or null. Should prevent "index out of bounds" error. /// @depricated /proc/listgetindex(list/L, index) if(LAZYLEN(L)) if(isnum(index) && ISINTEGER(index)) if(ISINRANGE(index,1,L.len)) return L[index] else if(index in L) return L[index] return //Return either pick(list) or null if list is not of type /list or is empty /// @depricated /proc/safepick(list/L) if(LAZYLEN(L)) return pick(L) //Checks if the list is empty /// @depricated /proc/isemptylist(list/L) if(!L.len) return TRUE return FALSE //Checks for specific types in a listc /proc/is_type_in_list(atom/A, list/L) if(!LAZYLEN(L) || !A) return FALSE for(var/type in L) if(istype(A, type)) return TRUE return FALSE //Checks for specific types in specifically structured (Assoc "type" = TRUE) lists ('typecaches') #define is_type_in_typecache(A, L) (A && length(L) && L[(ispath(A) ? A : A:type)]) //Checks for a string in a list /proc/is_string_in_list(string, list/L) if(!LAZYLEN(L) || !string) return for(var/V in L) if(string == V) return TRUE return //Removes a string from a list /proc/remove_strings_from_list(string, list/L) if(!LAZYLEN(L) || !string) return for(var/V in L) if(V == string) L -= V //No return here so that it removes all strings of that type return //returns a new list with only atoms that are in typecache L /proc/typecache_filter_list(list/atoms, list/typecache) RETURN_TYPE(/list) . = list() for(var/atom/A as anything in atoms) if (typecache[A.type]) . += A /proc/typecache_filter_list_reverse(list/atoms, list/typecache) RETURN_TYPE(/list) . = list() for(var/atom/atom as anything in atoms) if(!typecache[atom.type]) . += atom /proc/typecache_filter_multi_list_exclusion(list/atoms, list/typecache_include, list/typecache_exclude) . = list() for(var/atom/atom as anything in atoms) if(typecache_include[atom.type] && !typecache_exclude[atom.type]) . += atom ///Like typesof() or subtypesof(), but returns a typecache instead of a list /proc/typecacheof(path, ignore_root_path, only_root_path = FALSE) if(ispath(path)) var/list/types var/list/output = list() if(only_root_path) output[path] = TRUE else types = ignore_root_path ? subtypesof(path) : typesof(path) for(var/T in types) output[T] = TRUE return output else if(islist(path)) var/list/pathlist = path var/list/output = list() if(ignore_root_path) for(var/current_path in pathlist) for(var/subtype in subtypesof(current_path)) output[subtype] = TRUE return output if(only_root_path) for(var/current_path in pathlist) output[current_path] = TRUE else for(var/current_path in pathlist) for(var/subpath in typesof(current_path)) output[subpath] = TRUE return output /proc/typecacheof_assoc_list(list/pathlist, ignore_root_path = FALSE) . = list() if(!istype(pathlist)) return for(var/P in pathlist) var/value = pathlist[P] for(var/T in (ignore_root_path ? subtypesof(P) : typesof(P))) .[T] = value //Empties the list by setting the length to 0. Hopefully the elements get garbage collected /proc/clearlist(list/list) if(istype(list)) list.len = 0 return //Removes any null entries from the list //Returns TRUE if the list had nulls, FALSE otherwise /proc/listclearnulls(list/L) var/start_len = L.len var/list/N = new(start_len) L -= N return L.len < start_len /* * Returns list containing all the entries from first list that are not present in second. * If skiprep = 1, repeated elements are treated as one. * If either of arguments is not a list, returns null */ /proc/difflist(list/first, list/second, skiprep=0) if(!islist(first) || !islist(second)) return var/list/result = new if(skiprep) for(var/e in first) if(!(e in result) && !(e in second)) result += e else result = first - second return result /* * Returns list containing entries that are in either list but not both. * If skipref = 1, repeated elements are treated as one. * If either of arguments is not a list, returns null */ /proc/uniquemergelist(list/first, list/second, skiprep=0) if(!islist(first) || !islist(second)) return var/list/result = new if(skiprep) result = difflist(first, second, skiprep)+difflist(second, first, skiprep) else result = first ^ second return result //Picks a random element from a list based on a weighting system: //1. Adds up the total of weights for each element //2. Gets a number between 1 and that total //3. For each element in the list, subtracts its weighting from that number //4. If that makes the number 0 or less, return that element. //Will output null sometimes if you use decimals (e.g. 0.1 instead of 10) as rand() uses integers, not floats /proc/pickweight(list/L, base_weight = 1) var/total = 0 var/item for (item in L) if (!L[item]) L[item] = base_weight total += L[item] total = rand(base_weight, total) for (item in L) total -=L [item] if (total <= 0) return item return null /proc/pickweightAllowZero(list/L) //The original pickweight proc will sometimes pick entries with zero weight. I'm not sure if changing the original will break anything, so I left it be. var/total = 0 var/item for (item in L) if (!L[item]) L[item] = 0 total += L[item] total = rand(0, total) for (item in L) total -=L [item] if (total <= 0 && L[item]) return item return null //Picks a number of elements from a list based on weight. //This is highly optimised and good for things like grabbing 200 items from a list of 40,000 //Much more efficient than many pickweight calls /proc/pickweight_mult(list/L, quantity, base_weight = 1) //First we total the list as normal var/total = 0 var/item for (item in L) if (!L[item]) L[item] = base_weight total += L[item] //Next we will make a list of randomly generated numbers, called Requests //It is critical that this list be sorted in ascending order, so we will build it in that order //First one is free, so we start counting at 2 var/list/requests = list(rand(1, total)) for (var/i in 2 to quantity) //Each time we generate the next request var/newreq = rand()* total //We will loop through all existing requests for (var/j in 1 to requests.len) //We keep going through the list until we find an element which is bigger than the one we want to add if (requests[j] > newreq) //And then we insert the newqreq at that point, pushing everything else forward requests.Insert(j, newreq) break //Now when we get here, we have a list of random numbers sorted in ascending order. //The length of that list is equal to Quantity passed into this function //Next we make a list to store results var/list/results = list() //Zero the total, we'll reuse it total = 0 //Now we will iterate forward through the items list, adding each weight to the total for (item in L) total += L[item] //After each item we do a while loop while (requests.len && total >= requests[1]) //If the total is higher than the value of the first request results += item //We add this item to the results list requests.Cut(1,2) //And we cut off the top of the requests list //This while loop will repeat until the next request is higher than the total. //The current item might be added to the results list many times, in this process //By the time we get here: //Requests will be empty //Results will have a length of quality return results /// Pick a random element from the list and remove it from the list. /proc/pick_n_take(list/L) RETURN_TYPE(L[_].type) if(L.len) var/picked = rand(1,L.len) . = L[picked] L.Cut(picked,picked+1) //Cut is far more efficient that Remove() //Pick a random element from the list by weight and remove it from the list. //Result is returned as a list in the format list(key, value) /proc/pickweight_n_take(list/L, base_weight = 1) if (L.len) . = pickweight(L, base_weight) L.Remove(.) //Returns the top(last) element from the list and removes it from the list (typical stack function) /proc/pop(list/L) if(L.len) . = L[L.len] L.len-- /proc/popleft(list/L) if(L.len) . = L[1] L.Cut(1,2) /proc/sorted_insert(list/L, thing, comparator) var/pos = L.len while(pos > 0 && call(comparator)(thing, L[pos]) > 0) pos-- L.Insert(pos+1, thing) // Returns the next item in a list /proc/next_list_item(item, list/L) var/i i = L.Find(item) if(i == L.len) i = 1 else i++ return L[i] // Returns the previous item in a list /proc/previous_list_item(item, list/L) var/i i = L.Find(item) if(i == 1) i = L.len else i-- return L[i] //Randomize: Return the list in a random order /proc/shuffle(list/L) if(!L) return L = L.Copy() for(var/i=1, i= 0 ? /proc/cmp_ckey_asc : /proc/cmp_ckey_dsc) //Specifically for record datums in a list. /proc/sortRecord(list/L, field = "name", order = 1) GLOB.cmp_field = field return sortTim(L, order >= 0 ? /proc/cmp_records_asc : /proc/cmp_records_dsc) //any value in a list /proc/sortList(list/L, cmp=/proc/cmp_text_asc) return sortTim(L.Copy(), cmp) //uses sortList() but uses the var's name specifically. This should probably be using mergeAtom() instead /proc/sortNames(list/L, order=1) return sortTim(L.Copy(), order >= 0 ? /proc/cmp_name_asc : /proc/cmp_name_dsc) //Converts a bitfield to a list of numbers (or words if a wordlist is provided) /proc/bitfield2list(bitfield = 0, list/wordlist) var/list/r = list() if(islist(wordlist)) var/max = min(wordlist.len,16) var/bit = 1 for(var/i=1, i<=max, i++) if(bitfield & bit) r += wordlist[i] bit = bit << 1 else for(var/bit=1, bit<=65535, bit = bit << 1) if(bitfield & bit) r += bit return r // Returns the key based on the index #define KEYBYINDEX(L, index) (((index <= length(L)) && (index > 0)) ? L[index] : null) /proc/count_by_type(list/L, type) var/i = 0 for(var/T in L) if(istype(T, type)) i++ return i /proc/count_occurences_of_value(list/L, val, limit) //special thanks to salmonsnake . = 0 for (var/i in 1 to limit) if (L[i] == val) .++ /// Returns datum/data/record /proc/find_record(field, value, list/L) for(var/datum/data/record/R in L) if(R.fields[field] == value) return R return null //Move a single element from position fromIndex within a list, to position toIndex //All elements in the range [1,toIndex) before the move will be before the pivot afterwards //All elements in the range [toIndex, L.len+1) before the move will be after the pivot afterwards //In other words, it's as if the range [fromIndex,toIndex) have been rotated using a <<< operation common to other languages. //fromIndex and toIndex must be in the range [1,L.len+1] //This will preserve associations ~Carnie /proc/moveElement(list/L, fromIndex, toIndex) if(fromIndex == toIndex || fromIndex+1 == toIndex) //no need to move return if(fromIndex > toIndex) ++fromIndex //since a null will be inserted before fromIndex, the index needs to be nudged right by one L.Insert(toIndex, null) L.Swap(fromIndex, toIndex) L.Cut(fromIndex, fromIndex+1) //Move elements [fromIndex,fromIndex+len) to [toIndex-len, toIndex) //Same as moveElement but for ranges of elements //This will preserve associations ~Carnie /proc/moveRange(list/L, fromIndex, toIndex, len=1) var/distance = abs(toIndex - fromIndex) if(len >= distance) //there are more elements to be moved than the distance to be moved. Therefore the same result can be achieved (with fewer operations) by moving elements between where we are and where we are going. The result being, our range we are moving is shifted left or right by dist elements if(fromIndex <= toIndex) return //no need to move fromIndex += len //we want to shift left instead of right for(var/i=0, i toIndex) fromIndex += len for(var/i=0, i distance) //there is an overlap, therefore swapping each element will require more swaps than inserting new elements if(fromIndex < toIndex) toIndex += len else fromIndex += len for(var/i=0, i fromIndex) var/a = toIndex toIndex = fromIndex fromIndex = a for(var/i=0, i numeric value entries * All these procs modify in place. */ /proc/counterlist_scale(list/L, scalar) var/list/out = list() for(var/key in L) out[key] = L[key] * scalar . = out /proc/counterlist_sum(list/L) . = 0 for(var/key in L) . += L[key] /proc/counterlist_normalise(list/L) var/avg = counterlist_sum(L) if(avg != 0) . = counterlist_scale(L, 1 / avg) else . = L /proc/counterlist_combine(list/L1, list/L2) for(var/key in L2) var/other_value = L2[key] if(key in L1) L1[key] += other_value else L1[key] = other_value /proc/assoc_list_strip_value(list/input) var/list/ret = list() for(var/key in input) ret += key return ret /proc/compare_list(list/l,list/d) if(!islist(l) || !islist(d)) return FALSE if(l.len != d.len) return FALSE for(var/i in 1 to l.len) if(l[i] != d[i]) return FALSE return TRUE #define LAZY_LISTS_OR(left_list, right_list)\ ( length(left_list)\ ? length(right_list)\ ? (left_list | right_list)\ : left_list.Copy()\ : length(right_list)\ ? right_list.Copy()\ : null\ ) /proc/is_type_in_ref_list(path, list/L) if(!ispath(path))//not a path return for(var/i in L) var/datum/D = i if(!istype(D))//not an usable reference continue if(istype(D, path)) return TRUE /proc/safe_json_encode(list/L, default = "") . = default return json_encode(L) /proc/safe_json_decode(string, default = list()) . = default return json_decode(string)