The jsown Reference Manual

Table of Contents

The jsown Reference Manual

This is the jsown Reference Manual, version 1.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 16:32:51 2021 GMT+0.

1 Introduction

h1. jsown, high performance Common Lisp json parser

jsown is a high performance Common Lisp json parser.  Its aim is to allow for the fast parsing of json objects in CL.  Recently, functions and macros have been added to ease the burden of writing and editing jsown objects.

jsown allows you to parse json objects quickly to a modifiable lisp list and write them back.  If you only need partial retrieval of objects, jsown allows you to select the keys which you would like to see parsed.  jsown also has a json writer and some helper methods to alter the json objects themselves.

h2. parsing json objects

In order to parse a json object, simply use the @parse@ function.
  (jsown:parse "{\"foo\":\"bar\",\"baz\":100.25}")
  =>(:OBJ ("foo" . "bar") ("baz" . 401/4))

Without any extra arguments, the @parse@ function will return all keywords.  In order to select only a few keywords, you can add those keywords in which you're interested:
  (jsown:parse "{\"foo\":\"bar\",\"frolic\":100,\"fragrance\":10.01,\"for\":\"markup\"}" "foo" "frolic" "fragrance")
  => (:OBJ ("foo" . "bar") ("frolic" . 100) ("fragrance" . 1001/100))

In order to achieve high performance when parsing specific keywords, the keywords to be found should be known at compile time. The compiler-macro-function can calculate the keyword container with the requested keywords at compile-time.  When specifying the keywords in which you're interested you should ignore any escaped characters.  For instance, supplying the string "foo" will automatically match "f\\\\oo" too."

h2. Using jsown objects

jsown ships with some convience functions to inspect and alter the returned json content.

The fetching of the value given to a certain keyword may be done by using the @val@ function.  This function also has a setf defined on it.
The @(setf val)@ function may alter the original object, it is however not guaranteed to do so.
  (jsown:val '(:obj ("foo" . "bar") ("frolic" . 100) ("fragrance" . 1001/100)) "frolic")
  => 100
  (setf (jsown:val '(:obj ("foo" . "bar") ("frolic" . 100) ("fragrance" . 1001/100)) "frolic") "I wasn't here before")
  => (:obj ("foo" . "bar") ("frolic" . "I wasn't here before") ("fragrance" . 1001/100))

You can build objects by using the @val@ function too, albeit it doesn't look really sexy.
  (setf (jsown:val (setf (jsown:val (setf (jsown:val (jsown:empty-object) "foo") "bar") "bang") (list 1 2 3 "foo" 4 5)) "bingo") 24.93)
  =>(:obj ("bingo" . 24.93) ("bang" 1 2 3 "foo" 4 5) ("foo" . "bar"))

For building objects, the macros @new-js@ and @extend-js@ can be used.  @new-js@ creates a new jsown object, @extend-js@ extends an existing jsown object.

  (jsown:new-js
    ("foo" "bar")
    ("baz" (+ 100 0.25)))
  => (:obj ("baz" . 100.25) ("foo" . "bar"))

This object can be extended by use of @extend-js@.  Say we store the previously built json object in the parameter @*jsown-obj*@, then we can extend it like so:

  epicdb> (jsown:extend-js *jsown-obj*
    ("bing" "bang")
    ("ping" (print "Adding ping") "pong"))
  => (:obj ("ping" . "pong") ("bing" . "bang") ("baz" . 100.25) ("foo" . "bar"))

For didactical purposes, we've defined ping in more than one form.

In order to see which keywords have been defined in a parsed json object, you can use the @keywords@ function:
  (jsown:keywords '(:obj ("foo" . "bar") ("frolic" . 100) ("fragrance" . 1001/100)))
  => ("foo" "frolic" "fragrance")

You can traverse over all keywords by using the @do-json-keys@ macro.
  CL-USER> (jsown:do-json-keys (keyword value)
               '(:obj ("foo" . "bar") ("frolic" . 100) ("fragrance" . 1001/100))
             (format T "~A => ~A~&" keyword value))
  foo => bar
  frolic => 100
  fragrance => 1001/100
  NIL

Lastly, the @filter@ function allows you to traverse a tree of json objects and interpret its results.

  (jsown:filter (jsown:new-js
                  ("one" 100)
                  ("two" (jsown:new-js
                           ("three" (list (jsown:new-js ("four" (jsown:new-js
                                                                  ("five" "result-one"))))
                                          (jsown:new-js ("four" (jsown:new-js
                                                                  ("five" "result-two"))))
                                          (jsown:new-js ("four" (jsown:new-js
                                                                  ("five" "result-three")))))))))
                "two" "three" map "four" "five")
  => ("result-one" "result-two" "result-three")

h2. Writing json objects

jsown supports the writing of json objects too, use the @to-json@ CLOS method for this.  You can provide an implementation for this method for your own objects so those can easily be converted to json too (and it will ensure that nested objects are correctly transformed to json).
  (jsown:to-json '(:obj ("bingo" . 24.93) ("bang" 1 2 3 "foo" 4 5) ("foo" . "bar")))
  => "{\"bingo\":24.93,\"bang\":[1,2,3,\"foo\",4,5],\"foo\":\"bar\"}"

When reading json objects, jsown converts their content to the most lispy translation of what was in there.  As such json's @false@ will be translated to nil, which coincidentally also be the translation of json's @[]@.  When writing objects lisp's @nil@ is translated to the empty json list @[]@.  You can write json's @false@ by writing lisp's keywords @:false@ or @:f@.

  (jsown:to-json (jsown:new-js
                   ("items" nil)
                   ("falseIsEmptyList" :f)
                   ("success" t)))
"{\"success\":true,\"falseIsEmptyList\":false,\"items\":[]}"

2 Systems

The main system appears first, followed by any subsystem dependency.

2.1 jsown

Maintainer

Aad Versteden <madnificent@gmail.com>

Author

Aad Versteden <madnificent@gmail.com>

License

MIT

Description

Fast JSON parsing library. Mainly geared torwards fetching only a few keys of many objects, but efficient for other types of content too

Version

1.0.1

Source

jsown.asd (file)

Components

• packages.lisp (file)
• accessors.lisp (file)
• reader.lisp (file)
• writer.lisp (file)

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.

3.1 Lisp

3.1.1 jsown.asd

Location

jsown.asd

Systems

jsown (system)

3.1.2 jsown/packages.lisp

Parent

jsown (system)

Location

packages.lisp

Packages

jsown

3.1.3 jsown/accessors.lisp

Dependency

packages.lisp (file)

Parent

jsown (system)

Location

accessors.lisp

Exported Definitions

• do-json-keys (macro)
• empty-object (function)
• extend-js (macro)
• keyp (function)
• keywords (function)
• new-js (macro)
• remkey (function)
• val (function)
• (setf val) (setf expander)
• val-safe (function)

Internal Definitions

• append-key (function)
• jsown-object-p (function)
• key-val (function)
• overwrite-val (function)
• push-key (function)

3.1.4 jsown/reader.lisp

Dependency

accessors.lisp (file)

Parent

jsown (system)

Location

reader.lisp

Exported Definitions

• *parsed-empty-list-value* (special variable)
• *parsed-false-value* (special variable)
• *parsed-null-value* (special variable)
• *parsed-true-value* (special variable)
• build-key-container (compiler macro)
• build-key-container (function)
• filter (macro)
• parse (compiler macro)
• parse (function)
• parse-with-container (function)
• with-injective-reader (macro)

Internal Definitions

• +assume-fixnums+ (constant)
• +compile-unescape-json-strings+ (constant)
• buffer (structure)
• buffer-index (function)
• (setf buffer-index) (function)
• buffer-mark (function)
• (setf buffer-mark) (function)
• buffer-p (function)
• buffer-string (function)
• (setf buffer-string) (function)
• build-buffer (function)
• build-character-tree (compiler macro)
• build-character-tree (function)
• build-tree (function)
• char-in-arr (function)
• copy-buffer (function)
• current-char (function)
• decr-char (function)
• fetch-char (function)
• find-first-elts (function)
• high-surrogate-p (function)
• iterate-tree (function)
• make-buffer (function)
• make-jsown-filter (function)
• mark-buffer (function)
• mark-length (function)
• next-char (function)
• next-char/ (function)
• next-char/i (function)
• parse-string (function)
• peek-behind-char (function)
• read-array (function)
• read-key (function)
• read-number (function)
• read-number* (macro)
• read-object (function)
• read-partial-key (function)
• read-partial-object (function)
• read-value (function)
• set-read-number-part (macro)
• skip-array (function)
• skip-key (function)
• skip-number (function)
• skip-object (function)
• skip-string (function)
• skip-to (function)
• skip-to/ (function)
• skip-until (function)
• skip-until* (function)
• skip-until/ (function)
• skip-value (function)
• subseq-buffer-mark (function)
• subseq-tree (function)
• subseq-until (function)
• subseq-until/ (function)
• subseq-until/unescape (function)
• test-reader-speed (function)
• unescape-string/count (function)

3.1.5 jsown/writer.lisp

Dependency

reader.lisp (file)

Parent

jsown (system)

Location

writer.lisp

Exported Definitions

• as-js-bool (function)
• as-js-null (function)
• json-encoded-content (class)
• to-json (generic function)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json* (function)

Internal Definitions

• content (method)
• list-is-object-p (function)
• list-to-json (function)
• object-to-json (function)
• supplementary-plane-p (function)
• write-number* (function)
• write-object-to-stream (function)
• write-string* (function)

4 Packages

Packages are listed by definition order.

4.1 jsown

Source

packages.lisp (file)

Use List

common-lisp

Exported Definitions

• *parsed-empty-list-value* (special variable)
• *parsed-false-value* (special variable)
• *parsed-null-value* (special variable)
• *parsed-true-value* (special variable)
• as-js-bool (function)
• as-js-null (function)
• build-key-container (compiler macro)
• build-key-container (function)
• do-json-keys (macro)
• empty-object (function)
• extend-js (macro)
• filter (macro)
• json-encoded-content (class)
• keyp (function)
• keywords (function)
• new-js (macro)
• parse (compiler macro)
• parse (function)
• parse-with-container (function)
• remkey (function)
• to-json (generic function)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json (method)
• to-json* (function)
• val (function)
• (setf val) (setf expander)
• val-safe (function)
• with-injective-reader (macro)

Internal Definitions

• +assume-fixnums+ (constant)
• +compile-unescape-json-strings+ (constant)
• append-key (function)
• buffer (structure)
• buffer-index (function)
• (setf buffer-index) (function)
• buffer-mark (function)
• (setf buffer-mark) (function)
• buffer-p (function)
• buffer-string (function)
• (setf buffer-string) (function)
• build-buffer (function)
• build-character-tree (compiler macro)
• build-character-tree (function)
• build-tree (function)
• char-in-arr (function)
• content (generic function)
• content (method)
• copy-buffer (function)
• current-char (function)
• decr-char (function)
• fetch-char (function)
• find-first-elts (function)
• high-surrogate-p (function)
• iterate-tree (function)
• jsown-object-p (function)
• key-val (function)
• list-is-object-p (function)
• list-to-json (function)
• make-buffer (function)
• make-jsown-filter (function)
• mark-buffer (function)
• mark-length (function)
• next-char (function)
• next-char/ (function)
• next-char/i (function)
• object-to-json (function)
• overwrite-val (function)
• parse-string (function)
• peek-behind-char (function)
• push-key (function)
• read-array (function)
• read-key (function)
• read-number (function)
• read-number* (macro)
• read-object (function)
• read-partial-key (function)
• read-partial-object (function)
• read-value (function)
• set-read-number-part (macro)
• skip-array (function)
• skip-key (function)
• skip-number (function)
• skip-object (function)
• skip-string (function)
• skip-to (function)
• skip-to/ (function)
• skip-until (function)
• skip-until* (function)
• skip-until/ (function)
• skip-value (function)
• subseq-buffer-mark (function)
• subseq-tree (function)
• subseq-until (function)
• subseq-until/ (function)
• subseq-until/unescape (function)
• supplementary-plane-p (function)
• test-reader-speed (function)
• unescape-string/count (function)
• write-number* (function)
• write-object-to-stream (function)
• write-string* (function)

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.

5.1 Exported definitions

5.1.1 Special variables

Special Variable: *parsed-empty-list-value*

value to emit when parsing a json empty list ’[]’

Package

jsown

Source

reader.lisp (file)

Special Variable: *parsed-false-value*

value to emit when parsing json’s ’false’

Package

jsown

Source

reader.lisp (file)

Special Variable: *parsed-null-value*

value to emit when parsing json’s ’null’

Package

jsown

Source

reader.lisp (file)

Special Variable: *parsed-true-value*

value to emit when parsing json’s ’true’

Package

jsown

Source

reader.lisp (file)

5.1.2 Macros

Macro: do-json-keys (KEY VAL) OBJECT &body BODY

Iterates over the json key-value pairs

Package

jsown

Source

accessors.lisp (file)

Macro: extend-js OBJ &body SPECS

fills in a bunch of jsown values for obj. each spec should contain a list with the first element being the string which represents the key and the second being the form which evaluates to the value to which the key should be set.

it is heavily related to jsown-object, which fills in an empty object.

eg: (jsown-values (empty-object)
("kind" "onyx.Groupbox")
("components" (list (jsown-object
("content" "Hello World")
("tag" "h1"))
(jsown-object ("tag" "p") ("content" "This is jsown talkin!")))))

Package

jsown

Source

accessors.lisp (file)

Macro: filter ()

Fancy filtering for jsown-parsed objects.
spec can be one of the following:
[object] key to find. will transform into (jsown:val value key)
[cl:map] use this modifier with an [object] modifier after it, to filter all elements in the list.

Package

jsown

Source

reader.lisp (file)

Macro: new-js &body SPECS

creates a new empty object and fills it is per jsown-values

Package

jsown

Source

accessors.lisp (file)

Macro: with-injective-reader ()

Rebinds *parsed-*-value* so that reading json documents is injective and converting them back to json yields roughly the same document as the original. Rebinds:
- *parsed-true-value* => :true
- *parsed-false-value* => :false
- *parsed-null-value* => :null

Package

jsown

Source

reader.lisp (file)

5.1.3 Compiler macros

Compiler Macro: build-key-container ()

Package

jsown

Source

reader.lisp (file)

Compiler Macro: parse ()

Package

jsown

Source

reader.lisp (file)

5.1.4 Functions

Function: as-js-bool VALUE

returns <value> as a boolean value (in jsown format)

Package

jsown

Source

writer.lisp (file)

Function: as-js-null VALUE

returns <value> with nil being javascript’s null (in jsown format).

Package

jsown

Source

writer.lisp (file)

Function: build-key-container ()

Builds an internal structure to speed up the keywords which you can read. This should be used when the keywords needed are not known at compiletime, but you still want to parse those keywords of a lot of documents. If the keywords you are interested in are known at compiletime, the use of #’parse will automatically expand the kewords at compiletime.
parse-with-container takes the result of this function and will return the keywords which have been inserted here.

Package

jsown

Source

reader.lisp (file)

Function: empty-object ()

Returns an empty object which can be used to build new objects upon

Package

jsown

Source

accessors.lisp (file)

Function: keyp OBJECT KEY

Returns non-nil iff <object> has key <key>.

Package

jsown

Source

accessors.lisp (file)

Function: keywords OBJECT

Returns a list of all the keywords contained in the object

Package

jsown

Source

accessors.lisp (file)

Function: parse ()

Reads a json object from the given string, with the given keywords being the keywords which are fetched from the object. All parse functions assume <string> is not an empty json object. (string/= string "{}")

Package

jsown

Source

reader.lisp (file)

Function: parse-with-container ()

Parses the keywords which have been specified in the container from the json string json-string.
For most cases you can just use the parse function without a special key container. This is only here to support some cases where the building of the key container takes too much time. See #’parse for the normal variant.
See #’build-key-container for a way to build new keyword containers.

Package

jsown

Source

reader.lisp (file)

Function: remkey OBJECT KEY

Removes key from object.

Package

jsown

Source

accessors.lisp (file)

Function: to-json* OBJECT

Converts an object in internal jsown representation to a string containing the json representation

Package

jsown

Source

writer.lisp (file)

Function: val OBJECT KEY

Returns the value of the given key in object

Package

jsown

Source

accessors.lisp (file)

Setf Expander

(setf val) (setf expander)

Setf Expander: (setf val) PLACE KEY

see (setf getf) and val

Package

jsown

Source

accessors.lisp (file)

Reader

val (function)

Function: val-safe OBJECT KEY

Returns the value of <key> in <object> if <object> existed, or nil if it did not. A second value is returned which indicates whether or not the key was found.

Package

jsown

Source

accessors.lisp (file)

5.1.5 Generic functions

Generic Function: to-json OBJECT

Writes the given object to json in a generic way.

Package

jsown

Source

writer.lisp (file)

Methods

Method: to-json (N (eql nil))

Method: to-json (EMPTY-LIST (eql empty-list))

Method: to-json (FALSE (eql n))

Method: to-json (FALSE (eql null))

Method: to-json (FALSE (eql f))

Method: to-json (FALSE (eql false))

Method: to-json (TRUE (eql true))

Method: to-json (TRUE (eql t))

Method: to-json (TRUE (eql t))

Method: to-json (S symbol)

Method: to-json (TABLE hash-table)

Method: to-json (ARRAY array)

Method: to-json (LIST list)

Method: to-json (FLOAT float)

Method: to-json (RATIO ratio)

Method: to-json (NUMBER number)

Method: to-json (STRING string)

Method: to-json (CONTENT json-encoded-content)

5.1.6 Classes

Class: json-encoded-content ()

describes a json object whos content is serialized already.

Package

jsown

Source

writer.lisp (file)

Direct superclasses

standard-object (class)

Direct methods

• to-json (method)
• initialize-instance (method)
• content (method)

Direct slots

Slot: content

Initargs

:content

Readers

content (generic function)

5.2 Internal definitions

5.2.1 Constants

Constant: +assume-fixnums+

Compiles under the expectation that numbers (being integers and the float and non-float part of floats are fixnums. By default this is turned off. The performance hit seems to be around 2% to 8% in the mixed reader speed test.

Package

jsown

Source

reader.lisp (file)

Constant: +compile-unescape-json-strings+

Compiles support for unescaping json strings.
If you set this to nil upon compilation time strings and keywords aren’t escaped. This makes the library incompliant with json, but it does make it a few % faster. Could be handy when used in a mapreduce situation where you don’t mind debugging and speed is of utmost importance.

Package

jsown

Source

reader.lisp (file)

5.2.2 Macros

Macro: read-number* ()

This macro should be compared to inlined functions with respect to speed. The macro creates a tree of spaghetti code that can read jsown numbers to lisp numbers.

Package

jsown

Source

reader.lisp (file)

Macro: set-read-number-part ()

Package

jsown

Source

reader.lisp (file)

5.2.3 Compiler macros

Compiler Macro: build-character-tree ()

Package

jsown

Source

reader.lisp (file)

5.2.4 Functions

Function: append-key OBJECT KEY VALUE

Appends the given key to the object

Package

jsown

Source

accessors.lisp (file)

Function: buffer-index ()

Function: (setf buffer-index) ()

Package

jsown

Source

reader.lisp (file)

Function: buffer-mark ()

Function: (setf buffer-mark) ()

Package

jsown

Source

reader.lisp (file)

Function: buffer-p ()

Package

jsown

Source

reader.lisp (file)

Function: buffer-string ()

Function: (setf buffer-string) ()

Package

jsown

Source

reader.lisp (file)

Function: build-buffer ()

Makes a new buffer and ensures the string is of the correct type

Package

jsown

Source

reader.lisp (file)

Function: build-character-tree ()

Builds a character tree from a set of strings

Package

jsown

Source

reader.lisp (file)

Function: build-tree ()

Builds a tree from a range of lists and a function to compare its elements by

Package

jsown

Source

reader.lisp (file)

Function: char-in-arr ()

Returns t if <char> is found in <char-arr>, returns nil otherwise

Package

jsown

Source

reader.lisp (file)

Function: copy-buffer ()

Package

jsown

Source

reader.lisp (file)

Function: current-char ()

Returns the current character the buffer is pointing to

Package

jsown

Source

reader.lisp (file)

Function: decr-char ()

Sets the pointer to the previous char in the buffer

Package

jsown

Source

reader.lisp (file)

Function: fetch-char ()

Reads a character from the buffer and increases the index

Package

jsown

Source

reader.lisp (file)

Function: find-first-elts ()

Package

jsown

Source

reader.lisp (file)

Function: high-surrogate-p ()

character numbers between U+D800 and U+DFFF (inclusive) are reserved for use with the UTF-16 encoding form (as surrogate pairs) and do not directly represent characters.

Package

jsown

Source

reader.lisp (file)

Function: iterate-tree ()

Iterates a character-tree with the given character
Returns two values, being the new tree and whether or not this is an end-point.

Package

jsown

Source

reader.lisp (file)

Function: jsown-object-p OBJECT

returns non-nil iff we expect <object> to be a jsown object.

Package

jsown

Source

accessors.lisp (file)

Function: key-val OBJECT KEY

Returns the list which represents the key-val pair in the json object

Package

jsown

Source

accessors.lisp (file)

Function: list-is-object-p LIST

Package

jsown

Source

writer.lisp (file)

Function: list-to-json LIST

Package

jsown

Source

writer.lisp (file)

Function: make-buffer ()

Package

jsown

Source

reader.lisp (file)

Function: make-jsown-filter ()

Fancy filtering for jsown-parsed objects, functional implementation. look at jsown-filter for a working version.

Package

jsown

Source

reader.lisp (file)

Function: mark-buffer ()

Sets the mark of the buffer to the current character

Package

jsown

Source

reader.lisp (file)

Function: mark-length ()

Returns the current amount of characters in the marked piece of the buffer

Package

jsown

Source

reader.lisp (file)

Function: next-char ()

Sets the pointer to the next char in the buffer

Package

jsown

Source

reader.lisp (file)

Function: next-char/ ()

Sets the pointer to the next char in the buffer, ignores escaped characters (they start with a \) through

Package

jsown

Source

reader.lisp (file)

Function: next-char/i ()

Does what next-char/ does, but returns nil if no char was skipped or t if a char was skipped.

Package

jsown

Source

reader.lisp (file)

Function: object-to-json LIST

Package

jsown

Source

writer.lisp (file)

Function: overwrite-val OBJECT KEY VALUE

Overwrites the given key’s value with value. Errors out if the key didn’t exist

Package

jsown

Source

accessors.lisp (file)

Function: parse-string ()

Reads a JSON string from the stream
PRE: assumes the buffer’s index is at the starting "
POST: returns the matching string without converting escaped characters to their internal representation POST: the buffer’s index is right after the ending "

Package

jsown

Source

reader.lisp (file)

Function: peek-behind-char ()

Package

jsown

Source

reader.lisp (file)

Function: push-key OBJECT KEY VALUE

Adds the given key to the object at front

Package

jsown

Source

accessors.lisp (file)

Function: read-array ()

Reads a JSON array from the stream
PRE: assumes the buffer’s index is at the starting [ POST: returns a list containing all read objects POST: the buffer’s index is right after the ending ]

Package

jsown

Source

reader.lisp (file)

Function: read-key ()

Reads a key from the key-value list.
PRE: Assumes the buffer’s index is at the starting " of the key POST: The buffer’s index is right after the ending " of the key

Package

jsown

Source

reader.lisp (file)

Function: read-number ()

Reads a number from the buffer.
PRE: assumes the index is pointing to the first character representing the number
POST: the value of the character is returned
POST: the buffer’s index is at the position right after the last character representing the number

Package

jsown

Source

reader.lisp (file)

Function: read-object ()

reads an object, starting with { and ending with } into a in internal jsown object

Package

jsown

Source

reader.lisp (file)

Function: read-partial-key ()

reads a key from the buffer.
PRE: Assumes the buffer’s index is at the starting " of the key
POST: Returns (values key t) if the key was found as a valid key in the tree, or (values nil nil) if it was not POST: The buffer’s index is right after the ending " of the key

Package

jsown

Source

reader.lisp (file)

Function: read-partial-object ()

Reads an object from the buffer, but only when the key matches a key in the tree

Package

jsown

Source

reader.lisp (file)

Function: read-value ()

Reads a value from the stream.
This searches for the first meaningful character, and delegates to the right function for that character

Package

jsown

Source

reader.lisp (file)

Function: skip-array ()

Skips the contents of an array from the buffer PRE: assumes the buffer’s index is at the starting [ POST: the buffer’s index is right after the ending ]

Package

jsown

Source

reader.lisp (file)

Function: skip-key ()

Skips a key from the key-value list.
PRE: Assumes the buffer’s index is at the starting " of the key POST: The buffer’s index is right after the ending " of the key

Package

jsown

Source

reader.lisp (file)

Function: skip-number ()

Skips a number from the buffer
PRE: assumes the index is pointing to the first character representing the number.
POST: the buffer’s index is at the position right after the last character representing the number, possibly skipping spaces after that position

Package

jsown

Source

reader.lisp (file)

Function: skip-object ()

Skips an object from the buffer
PRE: Assumes the buffer’s index is at the starting { of the object POST: The buffer’s index is right after the ending } of the object

Package

jsown

Source

reader.lisp (file)

Function: skip-string ()

Skips the contents of an input string from the buffer. PRE: assumes the buffer’s index is at the starting " POST: the buffer’s index is right after the ending "

Package

jsown

Source

reader.lisp (file)

Function: skip-to ()

Skips characters until <char> has been found. <char> is the last char which is skipped see: skip-until

Package

jsown

Source

reader.lisp (file)

Function: skip-to/ ()

What skip-to does, but with the ignoring of \

Package

jsown

Source

reader.lisp (file)

Function: skip-until ()

Skips characters until <char> has been found. <char> is NOT skipped See: skip-to

Package

jsown

Source

reader.lisp (file)

Function: skip-until* ()

Skips characters until one of the characters in <char-arr> has been found. The character which was found is not read from the buffer.

Package

jsown

Source

reader.lisp (file)

Function: skip-until/ ()

What skip-until does, but with \ escaping

Package

jsown

Source

reader.lisp (file)

Function: skip-value ()

Skips a value from the stream.
This searches for the first meaningful character, and delegates to the right function for skipping that

Package

jsown

Source

reader.lisp (file)

Function: subseq-buffer-mark ()

Returns the content between index and mark for the current buffer result: (subseq buffer-string mark index))

Package

jsown

Source

reader.lisp (file)

Function: subseq-tree ()

Returns a sequence of the buffer, reading everything that matches with the given tree before end-char is found. end-char is not read from the buffer Returns nil if no sequence matching the tree could be found. It then stops iterating at the failed position
Skips #\

Package

jsown

Source

reader.lisp (file)

Function: subseq-until ()

Returns a subsequence of stream, reading everything before a character belonging to char-arr is found. The character which was found is not read from the buffer

Package

jsown

Source

reader.lisp (file)

Function: subseq-until/ ()

Does what subseq-until does, but does escaping too

Package

jsown

Source

reader.lisp (file)

Function: subseq-until/unescape ()

Does what subseq-until/ does, but unescapes the returned string

Package

jsown

Source

reader.lisp (file)

Function: supplementary-plane-p CHAR-CODE

character numbers between U+010000 and U+10FFFF (inclusive) are encoded as a surrogate pair.

Package

jsown

Source

writer.lisp (file)

Function: test-reader-speed ()

Package

jsown

Source

reader.lisp (file)

Function: unescape-string/count ()

Unescapes the given string based on JSOWN’s spec

Package

jsown

Source

reader.lisp (file)

Function: write-number* OBJECT OUTPUT

Package

jsown

Source

writer.lisp (file)

Function: write-object-to-stream OBJECT OUTPUT

Package

jsown

Source

writer.lisp (file)

Function: write-string* OBJECT OUTPUT

Package

jsown

Source

writer.lisp (file)

5.2.5 Generic functions

Generic Function: content OBJECT

Package

jsown

Methods

Method: content (JSON-ENCODED-CONTENT json-encoded-content)

automatically generated reader method

Source

writer.lisp (file)

5.2.6 Structures

Structure: buffer ()

A string-buffer which is used to operate on the strings
The use of a string-buffer allows us to read the data in bulk, and to operate on it, by using simple index manipulations. Reading the string up front removes the hassle of having a fixed-size maximal input

Package

jsown

Source

reader.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots

Slot: string

Type

simple-string

Initform

""

Readers

buffer-string (function)

Writers

(setf buffer-string) (function)

Slot: index

Type

fixnum

Initform

0

Readers

buffer-index (function)

Writers

(setf buffer-index) (function)

Slot: mark

Type

fixnum

Initform

0

Readers

buffer-mark (function)

Writers

(setf buffer-mark) (function)

Appendix A Indexes

A.1 Concepts

A.2 Functions

A.3 Variables

A.4 Data types