Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the big-string Reference Manual, generated automatically by Declt version 4.0 beta 2 "William Riker" on Thu Sep 15 03:20:07 2022 GMT+0.
Next: Systems, Previous: The big-string Reference Manual, Up: The big-string Reference Manual [Contents][Index]
BIG-STRING
==========
By Robert Smith
INTRODUCTION & USAGE
--------------------
BIG-STRING is a library for working with big strings. Despite the
name, BIG-STRING is also useful for general collections of strings. It
is very much like Java's StringBuilder class. Care has been taken to
make most operations linear in time at worst.
The usual trick to concatenate many strings together in (probably)
linear time is to use WITH-OUTPUT-TO-STRING:
CL-USER> (let ((strings '("this " "is " "a " "collection " "of " "strings.")))
(with-output-to-string (*standard-output*)
(dolist (string strings)
(princ string))))
"this is a collection of strings."
Depending on how WITH-OUTPUT-TO-STRING is implemented, this might not
be linear, and could be inefficient (the standard makes no complexity
guarantee).
BIG-STRING encapsulates this idea in a data structure:
BIG-STRING> (let* ((strings '("this " "is " "a " "collection " "of " "strings."))
(bs (make-big-string)))
(dolist (string strings bs)
(big-string-append bs string)))
#
We can convert this into a string in guaranteed linear time:
BIG-STRING> (string-of-big-string *)
"this is a collection of strings."
It is possble to do an analogous operation by creating a new string
stream using MAKE-STRING-OUTPUT-STRING, writing to the resulting
stream, and the obtaining the string using GET-OUTPUT-STREAM-STRING.
In a sense, we are building a string lazily. But more interestingly,
we can operate on it as if itself was a string.
BIG-STRING> (list (big-string-length **)
(big-string-char ** 10)
(big-string-substring ** 8 20))
(32 #\c "a collection")
LIMITATIONS
-----------
Right now, a few operations are slightly inefficient. Also, some more
string-like functions should be implemented.
The implementation right now takes about twice the time than SBCL
takes with string streams. However, with some type tweaking,
BIG-STRING goes at the same speed or faster, with about half the
memory.
Next: Files, Previous: Introduction, Up: The big-string Reference Manual [Contents][Index]
The main system appears first, followed by any subsystem dependency.
Big strings, similar to Java’s StringBuilder.
Robert Smith <quad@symbo1ics.com>
BSD 3-clause (see LICENSE)
Next: Packages, Previous: Systems, Up: The big-string Reference Manual [Contents][Index]
Files are sorted by type and then listed depth-first from the systems components trees.
Next: big-string/package.lisp, Previous: Lisp, Up: Lisp [Contents][Index]
big-string (system).
Next: big-string/big-string.lisp, Previous: big-string/big-string.asd, Up: Lisp [Contents][Index]
big-string (system).
Previous: big-string/package.lisp, Up: Lisp [Contents][Index]
package.lisp (file).
big-string (system).
Next: Definitions, Previous: Files, Up: The big-string Reference Manual [Contents][Index]
Packages are listed by definition order.
common-lisp.
Next: Indexes, Previous: Packages, Up: The big-string Reference Manual [Contents][Index]
Definitions are sorted by export status, category, package, and then by lexicographic order.
Next: Internals, Previous: Definitions, Up: Definitions [Contents][Index]
Next: Standalone methods, Previous: Public Interface, Up: Public Interface [Contents][Index]
Destructively append the string STRING to the big string BS.
Time complexity: O(1) [amortized]
Find the Nth char in the big string BS.
Time complexity: O(log n)
Return the total length of the big string BS.
Time complexity: O(1)
Compute the substring from the big string BS from the index START
to before the index END.
Time complexity: with n = end - start, O(n log n)
Build a string from the big string BS.
Time complexity: O(size(bs))
Next: Structures, Previous: Ordinary functions, Up: Public Interface [Contents][Index]
Previous: Standalone methods, Up: Public Interface [Contents][Index]
structure-object.
big-string::big-string-size
0
(and (vector big-string::big-string-size) (not simple-array))
(make-array 10 :element-type (quote big-string::big-string-size) :initial-element 0 :adjustable t :fill-pointer 0)
(and (vector simple-string) (not simple-array))
(make-array 10 :element-type (quote simple-string) :initial-element "" :adjustable t :fill-pointer 0)
Previous: Public Interface, Up: Definitions [Contents][Index]
Find the least value in the array ARRAY greater than N. Return NIL if N is negative or no such number is found.
Previous: Definitions, Up: The big-string Reference Manual [Contents][Index]
| Jump to: | (
B C F M P S |
|---|
| Jump to: | (
B C F M P S |
|---|
Next: Data types, Previous: Functions, Up: Indexes [Contents][Index]
| Jump to: | C S T |
|---|
| Jump to: | C S T |
|---|
| Jump to: | A B F P S T |
|---|
| Jump to: | A B F P S T |
|---|