public LSL_List llList2List(LSL_List src, int start, int end) { if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return new LSL_List(); return src.GetSublist(start, end); }
/// <summary> /// Insert the list identified by <src> into the /// list designated by <dest> such that the first /// new element has the index specified by <index> /// </summary> public LSL_List llListInsertList(LSL_List dest, LSL_List src, int index) { if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return new LSL_List(); LSL_List pref = null; LSL_List suff = null; if (index < 0) { index = index + dest.Length; if (index < 0) { index = 0; } } if (index != 0) { pref = dest.GetSublist(0, index - 1); if (index < dest.Length) { suff = dest.GetSublist(index, -1); return pref + src + suff; } return pref + src; } if (index < dest.Length) { suff = dest.GetSublist(index, -1); return src + suff; } return src; }
/// <summary> /// illListReplaceList removes the sub-list defined by the inclusive indices /// start and end and inserts the src list in its place. The inclusive /// nature of the indices means that at least one element must be deleted /// if the indices are within the bounds of the existing list. I.e. 2,2 /// will remove the element at index 2 and replace it with the source /// list. Both indices may be negative, with the usual interpretation. An /// interesting case is where end is lower than start. As these indices /// bound the list to be removed, then 0->end, and start->lim are removed /// and the source list is added as a suffix. /// </summary> public LSL_List llListReplaceList(LSL_List dest, LSL_List src, int start, int end) { if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return new LSL_List(); // Note that although we have normalized, both // indices could still be negative. if (start < 0) { start = start + dest.Length; } if (end < 0) { end = end + dest.Length; } // The comventional case, remove a sequence starting with // start and ending with end. And then insert the source // list. if (start <= end) { // If greater than zero, then there is going to be a // surviving prefix. Otherwise the inclusive nature // of the indices mean that we're going to add the // source list as a prefix. if (start > 0) { LSL_List pref = dest.GetSublist(0, start - 1); // Only add a suffix if there is something // beyond the end index (it's inclusive too). if (end + 1 < dest.Length) { return pref + src + dest.GetSublist(end + 1, -1); } return pref + src; } // If start is less than or equal to zero, then // the new list is simply a prefix. We still need to // figure out any necessary surgery to the destination // based upon end. Note that if end exceeds the upper // bound in this case, the entire destination list // is removed. if (end + 1 < dest.Length) { return src + dest.GetSublist(end + 1, -1); } return src; } // Finally, if start > end, we strip away a prefix and // a suffix, to leave the list that sits <between> ens // and start, and then tag on the src list. AT least // that's my interpretation. We can get sublist to do // this for us. Note that one, or both of the indices // might have been negative. return dest.GetSublist(end + 1, start - 1) + src; }