Section Header
  
  
    + name    := STRING;
  
    - comment := "String library.";
  
Section Inherit
  
  
    - parent_abstract_string:ABSTRACT_STRING := 
  
  
    - parent_arrayed:ARRAYED := 
  
Section ABSTRACT_STRING, ABSTRACT_ENTRY
  
  
    + storage:NATIVE_ARRAY[CHARACTER];
  
Section Public
    
  
    + count:INTEGER;
  
    + capacity:INTEGER;
  
  
  
 General :
  
  
  
    - set_storage tab:NATIVE_ARRAY[CHARACTER] <-
    
  
  
 Creation / Modification :
  
  
  
    - create needed_capacity:INTEGER :SELF <-
    
  
    - create_from_string str:ABSTRACT_STRING :SELF <-
    
  
    - make needed_capacity:INTEGER <-
  
         Initialize the string to have at least `needed_capacity'
  
         characters of storage.
    
  
    - make_empty <-
  
         Create an empty string
    
  
  
    - create_filled (c:CHARACTER,n:INTEGER) :SELF <-
    
  
    - make_filled (c:CHARACTER,n:INTEGER) <-
  
         Initialize string with `n` copies of `c`
    
  
    - twin:STRING <-
    
  
  
 Modification :
  
  
  
    - resize new_count:INTEGER <-
  
         Resize self. When `new_count' is greater than `count', 
  
         new positions are initialized with the default value of CHARACTER
  
  
    - set_capacity new_capacity:INTEGER <-
  
         Resize `capacity' self, but not count.
    
  
    - clear <-
  
         Clear out the current STRING.
  
         Note: internal `storage' memory is neither released nor shrunk.
    
  
    - copy other:ABSTRACT_STRING<-
  
         Copy `other' onto Current.
    
  
    - fill_with c:CHARACTER <-
  
         Replace every character with `c'.
    
  
    - replace_all old_char:CHARACTER with new_char:CHARACTER <-
  
         Replace all occurrences of the element `old_char' by `new_character'
    
  
    - append other:ABSTRACT_STRING <-
  
         Append `other' to Current.
    
  
    - prepend other:ABSTRACT_STRING <-
  
         Prepend `other' to Current
    
  
    - insert_string s:ABSTRACT_STRING to i:INTEGER <-
  
         Insert `s' at index `i', shifting characters from index `i'
  
         to `count' rightwards.
    
  
    - replace_substring s:ABSTRACT_STRING from start:INTEGER to end:INTEGER <-
  
         Replace the substring from start to end, inclusive, with s
          
  
    - put ch:CHARACTER to index:INTEGER<-
  
         Put `ch' at position `index'.
    
  
    - swap i1:INTEGER with i2: INTEGER <-
    
  
    - insert ch:CHARACTER to index:INTEGER <-
  
         Insert `ch' after position `index'.
  
  
    - insert ch:CHARACTER to index:INTEGER on nb:INTEGER <-
  
         Insert `ch' after position `index'.
      
  
    - shrink min_index:INTEGER to max_index:INTEGER <-
  
         Keep only the slice [`min_index' .. `max_index'] or nothing
  
         when the slice is empty.
    
  
    - remove index:INTEGER <-
  
         Remove character at position `index'.
    
  
    - add_first ch: CHARACTER <-
  
         Add `ch' at first position.
    
  
    - add_last ch:CHARACTER <-
  
         Append `ch' to string
    
  
    - append_character c:CHARACTER <-  
  
    - extend c:CHARACTER <- 
  
  
    - to_lower <-
  
         Convert all characters to lower case.
    
  
    - to_upper <-
  
         Convert all characters to upper case.
    
  
    - keep_head n:INTEGER <-
  
         Remove all characters except for the first `n'.
  
         Do nothing if `n' >= `count'.
    
  
    - keep_tail n:INTEGER <-
  
         Remove all characters except for the last `n'.
  
         Do nothing if `n' >= `count'.
    
  
    - remove_first n:INTEGER <-
  
         Remove `n' first characters.
  
         If `n' >= `count', remove all.
    
  
    - remove_between start:INTEGER to end:INTEGER <-
  
         Remove all characters from `strt_index' to `end_index' inclusive.
    
  
    - remove_suffix s:ABSTRACT_STRING <-
  
         Remove the suffix `s' of current string.
    
  
    - remove_last n:INTEGER <-
    
  
    - remove_tail n:INTEGER <-
        
  
    - remove_prefix s:ABSTRACT_STRING <-
  
         Remove the prefix `s' of current string.
    
  
    - left_adjust <-
  
         Remove leading blanks.
  
  
    - right_adjust <-
  
         Remove trailing blanks.
    
  
    - extend_multiple c:CHARACTER by n:INTEGER <-
  
         Extend Current with `n' times character `c'.
    
  
    - precede_multiple c:CHARACTER by n:INTEGER <-
  
         Prepend `n' times character `c' to Current.
    
  
    - extend_to_count c:CHARACTER until needed_count:INTEGER <-
  
         Extend Current with `c' until `needed_count' is reached.
  
         Do nothing if `needed_count' is already greater or equal
  
         to `count'.
    
  
    -  precede_to_count c:CHARACTER until needed_count:INTEGER <-
  
         Prepend `c' to Current until `needed_count' is reached.
  
         Do nothing if `needed_count' is already greater or equal
  
         to `count'.
    
  
    - reverse <-
  
         Reverse the string.
    
  
    - remove_all_occurrences ch:CHARACTER <-
  
         Remove all occurrences of `ch'.
    
  
    - extend_unless ch:CHARACTER <-
  
         Extend `Current' (using `extend') with `ch' unless `ch' is
  
         already the `last' character.
    
  
    - make_from_string model:ABSTRACT_STRING <-
  
         Initialize from the characters of `model'.
  
         Useful in proper descendants of STRING.
    
  
    - set_count new_count:INTEGER <-
    
  
  
 Interfacing with C string :
  
  
  
    - to_external:NATIVE_ARRAY[CHARACTER] <-
  
         Gives C access to the internal `storage' (may be dangerous).
  
         To be compatible with C, a null character is added at the end
  
         of the internal `storage'. This extra null character is not
  
         part of the Eiffel STRING.
    
  
    - from_external p:NATIVE_ARRAY[CHARACTER] <-
  
         Internal `storage' is set using `p' (may be dangerous because
  
         the external C string `p' is not duplicated).
  
         Assume `p' has a null character at the end in order to
  
         compute the Eiffel `count'. This extra null character
  
         is not part of the Eiffel STRING.
  
         Also consider `from_external_copy' to choose the most appropriate.
    
  
    - from_external_copy p:NATIVE_ARRAY[CHARACTER]  <-
  
         Internal `storage' is set using a copy of `p'.
  
         Assume `p' has a null character at the end in order to
  
         compute the Eiffel `count'. This extra null character
  
         is not part of the Eiffel STRING.
  
         Also consider `from_external' to choose the most appropriate.
    
  
  
 Guru section.
  
  
  
    - element_sizeof:INTEGER <- 
  
  
    - add_last_buffer buf:FAST_ARRAY[UINTEGER_8] from beg:INTEGER to end:INTEGER <-
      
  
    - item_byte idx:INTEGER offset ofs:INTEGER :UINTEGER_8 <-
    
  
    - restore_after_external <-