Type-Bound Procedures
            
    
procedure, public :: adjustc  => oop_adjustc         
    
    
        - 
                  
    private  function oop_adjustc(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in), | 
              optional |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: adjustl  => oop_adjustl         
    
    
        - 
                  
    private  function oop_adjustl(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: adjustr  => oop_adjustr         
    
    
        - 
                  
    private  function oop_adjustr(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: chars  => oop_switch         
    
    
        - 
                  
    private  function oop_switch(self) result(array)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    character(len=1), (len(self%str))
    
    
         
    
   
            
    
procedure, public :: compact  => oop_compact         
    
    
        - 
                  
    private  function oop_compact(self, char) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
 | 
              optional |             
              
             | 
            :: | 
            char | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: cpad  => oop_cpad         
    
    
        - 
                  
    private  function oop_cpad(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: crop  => oop_crop         
    
    
        - 
                  
    private  function oop_crop(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: dble  => oop_dble         
    
    
        - 
                  
    private  function oop_dble(self) result(value)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    doubleprecision
    
    
         
    
   
            
    
procedure, public :: expand  => oop_expand         
    
    
        - 
                  
    private  function oop_expand(self, escape_char) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character,
             | 
intent(in), | 
              optional |             
              
             | 
            :: | 
            escape_char | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: index  => oop_index         
    
    
        - 
                  
    private  function oop_index(self, substring, back) result(location)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            substring | 
            
                
             | 
        
        
            | 
              
              logical,
             | 
intent(in), | 
              optional |             
              
             | 
            :: | 
            back | 
            
                
             | 
        
    
  
    
    Return Value
    integer
    
    
         
    
   
            
    
procedure, public :: init  => init_string         
    
    
        - 
                  
    private  subroutine init_string(self)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string)
             | 
 | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
         
    
   
            
    
procedure, public :: int  => oop_int         
    
    
        - 
                  
    private  function oop_int(self) result(value)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    integer
    
    
         
    
   
            
    
procedure, public :: len  => oop_len         
    
    
        - 
                  
    private  function oop_len(self) result(length)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    integer
    
    
         
    
   
            
    
procedure, public :: len_trim  => oop_len_trim         
    
    
        - 
                  
    private  function oop_len_trim(self) result(length)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    integer
    
    
         
    
   
            
    
procedure, public :: lenset  => oop_lenset         
    
    
        - 
                  
    private  function oop_lenset(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: lower  => oop_lower         
    
    
        - 
                  
    private  function oop_lower(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: lpad  => oop_lpad         
    
    
        - 
                  
    private  function oop_lpad(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: match  => oop_glob         
    
    
        - 
                  
    private  function oop_glob(self, pattern) result(answer)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            pattern | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
procedure, public :: noesc  => oop_noesc         
    
    
        - 
                  
    private  function oop_noesc(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: notabs  => oop_notabs         
    
    
        - 
                  
    private  function oop_notabs(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
generic, public :: operator(*)  => string_multiply_value         
    
    
        - 
                  
    private  function string_multiply_value(self, value) result(other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              class(*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            value | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
generic, public :: operator(+)  => string_plus_value         
    
    
        - 
                  
    private  function string_plus_value(self, value) result(other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              class(*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            value | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
generic, public :: operator(-)  => string_minus_value         
    
    
        - 
                  
    private  function string_minus_value(self, value) result(other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              class(*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            value | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
generic, public :: operator(//)  => string_append_value         
    
    
        - 
                  
    private  function string_append_value(self, value) result(other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              class(*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            value | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
generic, public :: operator(/=)  => ne         
    
    
        - 
                  
    private  function ne(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
generic, public :: operator(<)  => lt         
    
    
        - 
                  
    private  function lt(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
generic, public :: operator(<=)  => le         
    
    
        - 
                  
    private  function le(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
generic, public :: operator(==)  => eq         
    
    
        - 
                  
    private  function eq(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
generic, public :: operator(>)  => gt         
    
    
        - 
                  
    private  function gt(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
generic, public :: operator(>=)  => ge         
    
    
        - 
                  
    private  function ge(self, other)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              type(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            other | 
            
                
             | 
        
    
  
    
    Return Value
    logical
    
    
         
    
   
            
    
procedure, public :: pad  => oop_pad         
    
    
        - 
                  
    private  function oop_pad(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: real  => oop_real         
    
    
        - 
                  
    private  function oop_real(self) result(value)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    real
    
    
         
    
   
            
    
procedure, public :: reverse  => oop_reverse         
    
    
        - 
                  
    private  function oop_reverse(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: rpad  => oop_rpad         
    
    
        - 
                  
    private  function oop_rpad(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: substitute  => oop_substitute         
    
    
        - 
                  
    private  function oop_substitute(self, old, new) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            old | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            new | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: transliterate  => oop_transliterate         
    
    
        - 
                  
    private  function oop_transliterate(self, old, new) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            old | 
            
                
             | 
        
        
            | 
              
              character(len=*),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            new | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: trim  => oop_trim         
    
    
        - 
                  
    private  function oop_trim(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: upper  => oop_upper         
    
    
        - 
                  
    private  function oop_upper(self) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)
    
    
         
    
   
            
    
procedure, public :: zpad  => oop_zpad         
    
    
        - 
                  
    private  function oop_zpad(self, length) result(string_out)  
  
  Arguments
      
    
      
        | Type | 
Intent | Optional |         Attributes | 
         | 
        Name | 
         | 
    
    
        
            | 
              
              class(string),
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            self | 
            
                
             | 
        
        
            | 
              
              integer,
             | 
intent(in) | 
               |             
              
             | 
            :: | 
            length | 
            
                
             | 
        
    
  
    
    Return Value
    type(string)