The StringBuffer constructor returns a string buffer object. String buffers are useful for incrementally building long strings from shorter substrings. The naive approach, which repeatedly concatenates each new substring to the end of an ever-growing string, is extremely inefficient. StringBuffer provides an efficient mechanism for building strings.

The StringBuffer object returned by the constructor is a module with six methods: clear, append, appendf, newline, space, and value.

The clear method empties the buffer; an empty string buffer represents the empty string . This method is executed only for effect; no useful value is returned, and no arguments are required.

The append method appends its argument, which must be a Maple string, to the string that the buffer represents. The buffer itself is returned. This allows you to chain multiple calls to the append method of a given buffer in a single expression. The appendf (``append formatted'') method allows you to append formatted strings. It accepts arguments identical to those accepted by sprintf.

The newline method appends newlines n to the buffer. If the argument n is supplied, it inserts that many newlines, otherwise it defaults to one.

The space method appends spaces n to the buffer. If the argument n is supplied, it inserts that many spaces, otherwise defaults to one.

The value method returns the string represented by the buffer. No arguments are required, but it accepts a clear option (of type truefalse) which, if set, causes the buffer to be cleared upon returning the string value.

The intention is that you can build a long string in a string buffer by repeatedly calling the append method of the buffer, and then retrieve the value of the represented string, as a string, by calling the value method. The clear method simply allows you to re-use an existing string buffer to create a new long string, once you are done with its current contents.

StringBuffer objects operate efficiently in algorithms for which the number of calls to the append method greatly exceeds the number of calls to the value or clear methods.

G := proc()
    description "extremely inefficient string concatenator";
    local    r;
    r := proc()
        if nargs = 0 then
            ""
        elif nargs = 1 then
            args[ 1 ]
        else
            cat( args[ 1 ], procname( args[ 2 .. -1 ] ) )
        end if
    end proc;
    r( args )
end proc:

F := proc()
    description "efficient version of G";
    local     b, r;
    b := StringTools:-StringBuffer();
    r := proc()
        if nargs = 1 then
            b:-append( args[ 1 ] )
        else
            b:-append( args[ 1 ] );
            procname( args[ 2 .. -1 ] )
        end if
    end proc;
    r( args ):-value()
end proc:

FilterFile := proc( fname::string, filter )
    local    b, line;
    b := StringTools:-StringBuffer();
    do
        line := readline( fname );
        if line = 0 then break end if;
        b:-append( filter( line ) )
    end do;
    b:-value()
end proc: