class FSTR < $IS_LT{FSTR}, $HASH, $STR |
---|
**** | Buffers for efficiently constructing strings by repeated concatenation using amortized doubling. Some useful features are: size:INT The current string size. create(n:INT):SAME A buffer of initial size `n'. copy:SAME A copy of self. aget(ind:INT):CHAR The character `ind'. aset(ind:INT, c:CHAR) Set character `ind' to `c'. is_eq(l:SAME):BOOL True if self equals l as strings. is_empty:BOOL True if self is the empty string. clear Make self represent the empty string. elt!:CHAR The characters in self. elt!(beg:INT):CHAR Characters starting at `beg'. elt!(beg,num:INT):CHAR `num' chars beginning at `beg'. elt!(beg,num,step:INT):CHAR `num' chars beginning at `beg',
____stepping_by_`step'. ind!:INT The indices of the buffer. contains(c:CHAR):BOOL True if self contains `c'. to_reverse Reverse the order of the characters. |
$STR | $HASH | $IS_EQ | $IS_LT{_} | FLIST{_} | $ARR{_} | $RO_ARR{_} | $CONTAINER{_} | $ELT{_} | $ELT | AREF{_} | COMPARE{_} |
attr loc:INT; .. Included as loc |
---|
**** | The index to insert the next element. |
attr loc:INT; .. Included as loc |
---|
**** | The index to insert the next element. |
acopy(f:FSTR) |
---|
acopy(beg:INT,src:FSTR) |
---|
acopy(beg:INT,src:STR) |
---|
acopy(s:STR) |
---|
acopyn(s:FSTR,n:INT) |
---|
acopyn(s:STR,n:INT) |
---|
aget(ind:INT):T .. Included as aget |
---|
**** | The element of self with index `ind'. Self may not be void. |
append(l:SAME):SAME .. Included as append |
---|
**** | Append `l' to the end of self and return the result. Self may be void. `l' mustn't equal self unless void. Modified(ben) - hopefully much more efficient - no iters |
append_file(nm:STR):SAME |
---|
**** | Open the file named `nm' in the current directory, append its contents to self, close the file, and return the new buffer. Do nothing if the file cannot be opened. |
append_file_range(nm:STR,st,sz:INT):SAME |
---|
**** | Open the file named `nm' in the current directory, append at most `sz' characters starting at `st' to self (only as many as are there), close the file, and return the new buffer. Do nothing if the file cannot be opened. |
array:ARRAY{T} .. Included as array |
---|
**** | An array containing the elements of self. Void if self is void. |
aset(ind:INT,val:T) .. Included as aset |
---|
**** | Set the element of self with index `ind' to `val'. Self may not be void. |
asize:INT .. Included as asize |
---|
**** | The number of elements in self. Classes which inherit this may replace this by a constant to get constant sized objects (and the compiler may optimize certain operations in this case). Built-in. |
clear |
---|
**** | Set self to the empty string. Retain the array. Self may be void. |
concat(l:SAME):SAME .. Included as concat |
---|
**** | Append 'l' destructively. 'l' mustn't equal self unless void. Modified (ben) - hopefully more efficient - no iters, single alloc |
contains(e: T): BOOL .. Included as contains |
---|
copy:SAME .. Included as copy |
---|
**** | A copy of self. Modified (ben) - ask Claudio |
create(a: ARRAY{T}): SAME .. Included as create |
---|
**** | Create a new FLIST from the elements in the array "a" Useful for using the array shorthand for specifying the elements |
create(sz:INT):SAME |
---|
**** | A new buffer of size `sz'. |
create(s:STR):SAME |
---|
**** | added by MBK to make STR::fstr:FSTR faster |
create:SAME |
---|
**** | A new buffer. |
create_empty_sized(n: INT): SAME .. Included as create_empty_sized |
---|
**** | Create an flist with n elements that are set to elt_nil |
create_from(a: $ELT{T}): SAME .. Included as create_from |
---|
**** | Create from any container |
delete(ind:INT) .. Included as delete |
---|
**** | Delete the element with index `ind' and move the last element in its place. Self may not be void. |
delete(ind: INT): SAME .. Included as delete |
---|
delete_elt(e: T) .. Included as delete_elt |
---|
**** | Delete first occurance of element e from the list. Consider using FSET. |
delete_elt(e: T): SAME .. Included as delete_elt |
---|
delete_elt_ordered(e: T) .. Included as delete_elt_ordered |
---|
**** | Similar to delete_ord, but for the element "e" |
delete_elt_ordered(e: T): SAME .. Included as delete_elt_ordered |
---|
delete_ordered(ind: INT) .. Included as delete_ordered |
---|
**** | Delete the element with index `ind' and move up all other elements (thus preseving order). More expensive than 'delete'. Self may not be void. |
delete_ordered(ind: INT): SAME .. Included as delete_ordered |
---|
difference(l:SAME):SAME .. Included as difference |
---|
**** | A new list containing the elements of self not in `l'. Doesn't modify self or `l'. Consider FSET{T} for better performance. Self may be void. |
elt_eq(e1,e2:ETP):BOOL .. Included as elt_eq |
---|
**** | The "less than" relation used in the sorting routines. Compares the object "id" by default. May be redefined in descendants. |
elt_hash(e:ETP):INT .. Included as elt_hash |
---|
**** | A hash value associated with an element. Must have the property that if "elt_eq(e1,e2)" then "elt_hash(e1)=elt_hash(e2)". Can be defined to always return 0, but many routines will then become quadratic. Uses object "id" by default. May be redefined in descendants. |
elt_lt(e1,e2:ETP):BOOL .. Included as elt_lt |
---|
**** | The "less than" relation used in the sorting routines. Compares the object "id" by default. May be redefined in descendants. |
elt_nil: ETP .. Included as elt_nil |
---|
**** | Return the nil value. If the element is under $NIL then return e.nil. Otherwise, return void
_ |
elt_str(e: T,i: INT): STR .. Included as elt_str |
---|
equals(l: $RO_ARR{T}): BOOL .. Included as equals |
---|
**** | Return true if the elemetns of "l" are the same as the elements of self |
fill(e: T) .. Included as fill |
---|
has(e:T):BOOL .. Included as has |
---|
**** | True if `e' is contained in self. |
has_ind(i: INT): BOOL .. Included as has_ind |
---|
hash0:INT |
---|
**** | An inexpensive to compute hash function of self. Gives an INT with rightmost 24 bits. Also gives lousy hash functions. Void gives 0. |
hash:INT |
---|
**** | Keep It Simple, Stupid. |
head(i:INT):SAME |
---|
**** | The first `i' characters of self. Self may be void if i=0. |
index_of(e:T):INT .. Included as index_of |
---|
**** | The list index of `e'. -1 if the list is void or the element is not present (not fast). Consider using FSET{T}. |
inds: ARRAY{INT} .. Included as inds |
---|
insert_after(ind:INT, val:T): SAME .. Included as insert_after |
---|
**** | Insert the value "val" after the index "ind". push all later elements upwards. |
insert_all_after(ind:INT, val:$CONTAINER{T}):SAME .. Included as insert_all_after |
---|
insert_all_before(ind:INT, val:$CONTAINER{T}) :SAME .. Included as insert_all_before |
---|
insert_before(ind:INT, val:T): SAME .. Included as insert_before |
---|
**** | Insert val just before index "ind" |
intersect(l:SAME):SAME .. Included as intersect |
---|
**** | A new list containing the elements in both self and `l'. Doesn't modify self or `l'. Consider FSET{T} for better performance. Self may be void. |
is_elt_nil(e:ETP):BOOL .. Included as is_elt_nil |
---|
is_empty:BOOL .. Included as is_empty |
---|
**** | True if the list is empty or void. |
is_eq(s:SAME):BOOL |
---|
**** | True if `s' equals self. Either may be void. MBK. |
is_eq(s:STR):BOOL |
---|
**** | so you can say `` if FSTR = "blabitty blah blah blah" '' |
is_eq(arg: $OB): BOOL .. Included as is_eq |
---|
is_lower:BOOL |
---|
**** | True if each alphabetic character of self is lower case. Self may be void. |
is_lt(s:SAME):BOOL |
---|
**** | True if self is lexicographically before `s'. Void is before everything else. |
is_upper:BOOL |
---|
**** | True if each alphabetic character of self is upper case. Self may be void. |
length:INT |
---|
**** | The number of characters in self. Another name for `size'. |
plus(b:BOOL):SAME |
---|
**** | Append `b' to self and return it. |
plus(c:CHAR):SAME |
---|
**** | Append `c' to self and return it. |
plus(f:FLT):SAME |
---|
**** | Append `f' to self and return it. |
plus(s:SAME):SAME |
---|
**** | Append `s' to self and return it.post result.str = initial(self.str) + initial(s.str) |
plus(i:INT):SAME |
---|
**** | Append `i' to self and return it. |
plus(s:STR):SAME |
---|
**** | Append the string `s' to self and return it. modified by MBK et al to make it go fast. Called by compiler frequently. |
pop:T .. Included as pop |
---|
**** | Return the top element and shrink the list. Void if the list is empty or void. |
push(c:CHAR):SAME |
---|
**** | Add a new character to the end of self and return it. If self is void, create a new list. Usage: `l:=l.push(e)'. This routine needs to go fast too, which is the reason behind the "l" temporary. Modified by MBK. |
push_if_new(e:T):SAME .. Included as push_if_new |
---|
**** | Push `e' if it is not already present in the list. Self may be void. Usage is: `l:=l.push_if_new(e)'. Consider using FSET{T}. |
reset .. Included as reset |
---|
**** | Semantically identical to clear, but don't reset array values (space may not be freed). Useful for quickly emptying the list when you know it won't matter. |
size:INT .. Included as size |
---|
**** | The current size. Self may be void. |
str:STR |
---|
**** | A string version of self. |
sublist(beg,num:INT):SAME .. Included as sublist |
---|
**** | A new list with `num' entries copied from self starting at `beg'. Self may not be void. |
substring(beg,num:INT):SAME |
---|
**** | The substring with `num' charcters whose first character has index `beg'. Self may be void if beg=0 and num=0. |
sym_difference(l:SAME):SAME .. Included as sym_difference |
---|
**** | A new list containing the elements in self or `l' but not both. Doesn't modify self or `l'. Consider FSET{T} for better performance. Self may be void. |
tail(i:INT):SAME |
---|
**** | The last `i' characters of self. Self may be void if i=0. |
thumbprint:STR |
---|
**** | Compute a representation to use in place of the whole text. The probability that two thumbprints are the same for two different FSTRs should be vanishingly small. This is a little more paranoid than the hash function. |
to_reverse .. Included as to_reverse |
---|
**** | Reverse the order of the elements in self. Self may be void. |
top:T .. Included as top |
---|
**** | The value of the top of the list. Void if the list is empty or void. |
union(l:SAME):SAME .. Included as union |
---|
**** | A new list containing the elements in self unioned with those in `l'. Doesn't modify self or `l'. Self may be void. Consider using FSET{T} for better performance. |
valid_after_ind(i: INT): BOOL .. Included as valid_after_ind |
---|
valid_before_ind(i:INT): BOOL .. Included as valid_before_ind |
---|
elt!(once beg:INT):T .. Included as elt! |
---|
**** | Yield the elements of self starting at `beg'. Don't insert elements while calling this. Modified (ben) - Looked at fast version - does not seem to be optimized out. Must ask Claudio about this |
elt!(once beg,once num:INT):T .. Included as elt! |
---|
**** | Yield `num' successive elements starting at index `beg'. Don't insert elements while calling this. |
elt!(once beg,once num,once step:INT):T .. Included as elt! |
---|
**** | Yield `num' elements starting at `beg' stepping by `step'. |
elt!:T .. Included as elt! |
---|
**** | Yield the elements of self in order. Self may be void. Don't insert elements while calling this. Modified (ben) - must ask Claudio |
ind!:INT .. Included as ind! |
---|
separate!(s:SAME):FSTR |
---|
**** | On the first iteration just outputs `s', on successive iterations it outputs self followed by `s'. Useful for forming lists, Eg: loop #OUT + ", ".fstr.separate!(a.elt!) end; incorporated Erik's fixes |
set!(e: T) .. Included as set! |
---|
aclear .. Included as aclear |
---|
**** | Set each element of self to nil. Built-in. |
acopy(beg,num:INT, src:SAME) .. Included as acopy |
---|
**** | Copy `num' elements from `src' to self starting at index `beg' of self. |
acopy(beg,num,srcbeg:INT, src:SAME) .. Included as acopy |
---|
**** | Copy `num' elements from `src' to self starting at index `beg' of self and index `srcbeg' of `src'. Built-in. |
aelt!(once beg:INT):T .. Included as aelt! |
---|
**** | Yield each element of self starting at `beg'. Built-in. |
aelt!(once beg,once num:INT):T .. Included as aelt! |
---|
**** | Yield `num' successive elements of self starting at index `beg'. Built-in. |
aelt!(once beg,once num,once step:INT):T .. Included as aelt! |
---|
**** | Yield `num' elements of self starting at `beg' and stepping by `step' which must not be zero. Built-in. |
aelt!:T .. Included as aelt! |
---|
**** | Yield each element of self in order. Built-in. |
aind!:INT .. Included as aind! |
---|
**** | Yield the indices of self in order. |
aget(ind:INT):T .. Included as aref_aget |
---|
**** | The element of self with index `ind'. Built-in. |
aset(ind:INT, val:T) .. Included as aref_aset |
---|
**** | Set the element of self with index `ind' to `val'. Built-in. |
array_ptr:C_PTR .. Included as array_ptr |
---|
aset!(val:T) .. Included as aset! |
---|
**** | Set successive elements of self to the values `val'. Built-in. |
aset!(once beg:INT,val:T) .. Included as aset! |
---|
**** | Set successive elements of self starting at `beg' to the values `val'. |
aset!(once beg,once num:INT,val:T) .. Included as aset! |
---|
**** | Set `num' successive elements of self starting at `beg' to the values `val'. |
aset!(once beg,once num,once step:INT, val:T) .. Included as aset! |
---|
**** | Set `num' elements of self starting at `beg' stepping by `step' to the values `val'. `step' must not be zero. |
expand_to_size(new_size: INT): SAME .. Included as expand_to_size |
---|
**** | Expand space so that the result has space for "new_size" elements. Then set the location to new_size, indicating that it is filled After this is done, the resulting array will be of size = new_size and will have all the old elements of "self" copied over and the remaining elements (if any) void |
is_eq_helper(s:SAME,i:INT):BOOL |
---|
is_eq_helper(s:STR,i:INT):BOOL |
---|
is_legal_aelts_arg( beg, num, step:INT) :BOOL .. Included as is_legal_aelts_arg |
---|
**** | True if the arguments are legal values for `aelts'. |
is_legal_elts_arg(beg,num,step:INT):BOOL .. Included as is_legal_elts_arg |
---|
**** | True if the arguments are legal values for `elts'. |
push_downward(from_ind: INT, by: INT) .. Included as push_downward |
---|
**** | Push all the elements from index "from_ind" downward by "ind" spots. The last elements are pushed off the end |