-
Notifications
You must be signed in to change notification settings - Fork 0
/
recursive-registry.ts
85 lines (83 loc) · 2.67 KB
/
recursive-registry.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
import * as assert from './lib/assert'
import type {RegisterableType, TypeAndName} from './recursive-registry-type'
import {ArrayType, MapType, SetType, StructType, TupleType} from './types'
//A map of names of recursive types to their types
const registeredTypes = new Map<string, RegisterableType>()
/**
* Registers a type with a name so
* the name can be used in a [[RecursiveType]].
* Due to implementation limitations,
* the type must be one of the following types:
* - [[ArrayType]]
* - [[MapType]]
* - [[SetType]]
* - [[StructType]]
* - [[TupleType]]
*
* If you need to use a different type, wrap it
* in a single-field [[StructType]].
*
* THIS METHOD OF REGISTERING RECURSIVE TYPES HAS BEEN DEPRECATED.
* Instead, please use [[RecursiveType.setType]]:
* ````javascript
* //A binary tree of unsigned bytes
* let treeType = new sb.RecursiveType('tree-node')
* treeType.setType(new sb.StructType({
* left: new sb.OptionalType(treeType),
* value: new sb.UnsignedByteType,
* right: new sb.OptionalType(treeType)
* }))
* ````
*
* Example:
* ````javascript
* //A binary tree of unsigned bytes
* let treeType = new sb.RecursiveType('tree-node')
* sb.registerType({
* type: new sb.StructType({
* left: new sb.OptionalType(treeType),
* value: new sb.UnsignedByteType,
* right: new sb.OptionalType(treeType)
* }),
* name: 'tree-node' //name must match name passed to RecursiveType constructor
* })
* ````
*
* @param type The type to register
* @param name The name to associate it with
* @throws If a type is already registered under the name
*/
export function registerType({type, name}: TypeAndName): void {
assert.instanceOf(type, [ //these are the only types capable of being recursive and having a known base value, e.g. [] or new Map
ArrayType,
MapType,
SetType,
StructType,
TupleType
])
assert.instanceOf(name, String)
if (isRegistered(name)) throw new Error(`"${name}" is already a registered type`)
registeredTypes.set(name, type)
}
/**
* Gets the recursive type
* registered with the specified name
* @param name The name of the registered type
* @return The registered type
* @throws If no type is registered with that name
*/
export function getType(name: string): RegisterableType {
assert.instanceOf(name, String)
const type = registeredTypes.get(name)
if (!type) throw new Error(`"${name}" is not a registered type`)
return type
}
/**
* Returns whether the specified name
* already has a recursive type registered with it
* from a call to [[registerType]]
* @param name The name to check
* @return Whether the name has been mapped to a type
*/
export const isRegistered = (name: string): boolean =>
registeredTypes.has(name)