StringTools - Maple Programming Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Programming : Names and Strings : StringTools Package : Miscellaneous Utilities : StringTools/StringBuffer

StringTools

  

StringBuffer

  

string buffer constructor

 

Calling Sequence

Parameters

Description

Examples

Calling Sequence

b := StringBuffer()

b:-clear()

b:-append( s )

b:-appendf( fmt, ... )

b:-newline(n)

b:-space(n)

b:-value()

b:-value( opt )

Parameters

b

-

string buffer object

s

-

Maple string

fmt

-

Maple string; format string as for sprintf

n

-

(optional) non-negative integer; number of characters inserted, default is 1

opt

-

(optional) option of the form clear = true (or just clear) or clear = false

Description

• 

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.

Examples

withStringTools:

bStringBuffer:

b:-appendThe

The

(1)

b:-appendquick :-appendbrown :-appendfox.

The quick ...ick brown

(2)

b:-value

The quick brown fox.quick brown

(3)

b:-clear:b:-appendf%a,2+3sinxy:b:-value

2+3*sin(x/y)

(4)

Use of a StringBuffer is much more efficient that the naive approach shown here.

N1000:

s:

txtRandom10,'lower'

txtyhcmxxkyzm

(5)

sttime:foritoNdoscats,txtend do:timest

0.008

(6)

b:-clear:sttime:foritoNdob:-appendtxtend do:timest

0.003

(7)

evalbb:-value=s

true

(8)

Here is another, more subtle example.

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:

This can be transformed into an O(1) algorithm by passing a string buffer to the recursive calls.

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:

sseqRandom10,'lower',i=1..1000:

timeGs

0.020

(9)

timeFs

0.009

(10)

Here is a procedure to read the contents of a file, one line at a time, applying a given filtering operation to each line.

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:

filenameFileTools:-JoinPathkerneloptsdatadir,help,StringTools,cbc03.txt

filename/usr/local/repository/build/rdgetroll8/maple/slot0/data/help/StringTools/cbc03.txt

(11)

FilterFilefilename,s→s

Francesco Totti scored the game-winning goal on a penalty shot in injury time to lift Italy to a dramatic 1-0 win over Australia Monday at the World Cup in Kaiserslautern, Germany.

(12)

FilterFilefilename,Trim

Francesco Totti scored the game-winning goal on a penalty shot in injury timeto lift Italy to a dramatic 1-0 win over Australia Monday at the World Cup inKaiserslautern, Germany.

(13)

FilterFilefilename,s→`if`IsSpaces,,s

Francesco Totti scored the game-winning goal on a penalty shot in injury time to lift Italy to a dramatic 1-0 win over Australia Monday at the World Cup in Kaiserslautern, Germany.

(14)

See Also

cat

fclose

module

readline

seq

string

StringTools

StringTools[IsSpace]

StringTools[Join]

StringTools[Trim]