-
Notifications
You must be signed in to change notification settings - Fork 443
/
list.ts
159 lines (127 loc) · 3.32 KB
/
list.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
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
import { mapIterable } from './util.js'
import type { PeerId } from '@libp2p/interface'
/**
* We can't use PeerIds as list entries because list entries are
* compared using same-value-zero equality, so this is just
* a map that stringifies the PeerIds before storing them.
*
* PeerIds cache stringified versions of themselves so this
* should be a cheap operation.
*
* @example
*
* ```TypeScript
* import { peerList } from '@libp2p/peer-collections'
*
* const list = peerList()
* list.push(peerId)
* ```
*/
export class PeerList {
private list: PeerId[]
constructor (list?: PeerList | Iterable<PeerId>) {
this.list = []
if (list != null) {
for (const value of list) {
this.list.push(value)
}
}
}
[Symbol.iterator] (): IterableIterator<PeerId> {
return mapIterable<[number, PeerId], PeerId>(
this.list.entries(),
(val) => {
return val[1]
}
)
}
concat (list: PeerList): PeerList {
const output = new PeerList(this)
for (const value of list) {
output.push(value)
}
return output
}
entries (): IterableIterator<[number, PeerId]> {
return mapIterable<[number, PeerId], [number, PeerId]>(
this.list.entries(),
(val) => {
return [val[0], val[1]]
}
)
}
every (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): boolean {
return this.list.every((peerId, index) => {
return predicate(peerId, index, this)
})
}
filter (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): PeerList {
const output = new PeerList()
this.list.forEach((peerId, index) => {
if (predicate(peerId, index, this)) {
output.push(peerId)
}
})
return output
}
find (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): PeerId | undefined {
const peerId = this.list.find((peerId, index) => {
return predicate(peerId, index, this)
})
if (peerId == null) {
return undefined
}
return peerId
}
findIndex (predicate: (peerId: PeerId, index: number, arr: PeerList) => boolean): number {
return this.list.findIndex((peerId, index) => {
return predicate(peerId, index, this)
})
}
forEach (predicate: (peerId: PeerId, index: number, arr: PeerList) => void): void {
this.list.forEach((peerId, index) => {
predicate(peerId, index, this)
})
}
includes (peerId: PeerId): boolean {
return this.includes(peerId)
}
indexOf (peerId: PeerId): number {
return this.list.findIndex(id => id.equals(peerId))
}
pop (): PeerId | undefined {
const peerId = this.list.pop()
if (peerId == null) {
return undefined
}
return peerId
}
push (...peerIds: PeerId[]): void {
for (const peerId of peerIds) {
this.list.push(peerId)
}
}
shift (): PeerId | undefined {
const peerId = this.list.shift()
if (peerId == null) {
return undefined
}
return peerId
}
unshift (...peerIds: PeerId[]): number {
let len = this.list.length
for (let i = peerIds.length - 1; i > -1; i--) {
len = this.list.unshift(peerIds[i])
}
return len
}
clear (): void {
this.list = []
}
get length (): number {
return this.list.length
}
}
export function peerList (): PeerList {
return new PeerList()
}