design: Initial PDL design

It's clear it won't survive this change because I can't even test
it, so who knows if its good enough to have in main.

codec/decode.go

@@ -0,0 +1,100 @@
+package codec
+
+import "io"
+
+// Decoder wraps an [io.Reader] and decodes data from it.
+type Decoder struct {
+	io.Reader
+}
+
+// ReadFull calls [io.ReadFull] on the reader.
+func (this *Decoder) ReadFull(buffer []byte) (n int, err error) {
+	return io.ReadFull(this, buffer)
+}
+
+// ReadByte decodes a single byte from the input reader.
+func (this *Decoder) ReadByte() (value byte, n int, err error) {
+	uncasted, n, err := this.ReadUint8()
+	return byte(uncasted), n, err
+}
+
+// ReadInt8 decodes an 8-bit signed integer from the input reader.
+func (this *Decoder) ReadInt8() (value int8, n int, err error) {
+	uncasted, n, err := this.ReadUint8()
+	return int8(uncasted), n, err
+}
+
+// ReadUint8 decodes an 8-bit unsigned integer from the input reader.
+func (this *Decoder) ReadUint8() (value uint8, n int, err error) {
+	buffer := [1]byte { }
+	n, err = this.ReadFull(buffer[:])
+	return uint8(buffer[0]), n, err
+}
+
+// ReadInt16 decodes an 16-bit signed integer from the input reader.
+func (this *Decoder) ReadInt16() (value int16, n int, err error) {
+	uncasted, n, err := this.ReadUint16()
+	return int16(uncasted), n, err
+}
+
+// ReadUint16 decodes an 16-bit unsigned integer from the input reader.
+func (this *Decoder) ReadUint16() (value uint16, n int, err error) {
+	buffer := [2]byte { }
+	n, err = this.ReadFull(buffer[:])
+	return uint16(buffer[0]) << 8 |
+		uint16(buffer[1]), n, err
+}
+
+// ReadInt32 decodes an 32-bit signed integer from the input reader.
+func (this *Decoder) ReadInt32() (value int32, n int, err error) {
+	uncasted, n, err := this.ReadUint32()
+	return int32(uncasted), n, err
+}
+
+// ReadUint32 decodes an 32-bit unsigned integer from the input reader.
+func (this *Decoder) ReadUint32() (value uint32, n int, err error) {
+	buffer := [4]byte { }
+	n, err = this.ReadFull(buffer[:])
+	return uint32(buffer[0]) << 24 |
+		uint32(buffer[1]) << 16 |
+		uint32(buffer[2]) << 8 |
+		uint32(buffer[3]), n, err
+}
+
+// ReadInt64 decodes an 64-bit signed integer from the input reader.
+func (this *Decoder) ReadInt64() (value int64, n int, err error) {
+	uncasted, n, err := this.ReadUint64()
+	return int64(uncasted), n, err
+}
+
+// ReadUint64 decodes an 64-bit unsigned integer from the input reader.
+func (this *Decoder) ReadUint64() (value uint64, n int, err error) {
+	buffer := [8]byte { }
+	n, err = this.ReadFull(buffer[:])
+	return uint64(buffer[0]) << 56 |
+		uint64(buffer[1]) << 48 |
+		uint64(buffer[2]) << 48 |
+		uint64(buffer[3]) << 32 |
+		uint64(buffer[4]) << 24 |
+		uint64(buffer[5]) << 16 |
+		uint64(buffer[6]) << 8 |
+		uint64(buffer[7]), n, err
+}
+
+// ReadGBEU decodes a growing unsigned integer of up to 64 bits from the input
+// reader.
+func (this *Decoder) ReadGBEU() (value uint64, n int, err error) {
+	var fullValue uint64
+	for {
+		chunk, nn, err := this.ReadByte()
+		if err != nil { return 0, n, err }
+		n += nn
+		
+		fullValue *= 0x80
+		fullValue += uint64(chunk & 0x7F)
+		ccb := chunk >> 7
+		if ccb == 0 {
+			return fullValue, n, nil
+		}
+	}
+}

codec/encode.go

@@ -0,0 +1,95 @@
+package codec
+
+import "io"
+
+// Encoder wraps an [io.Writer] and encodes data to it.
+type Encoder struct {
+	io.Writer
+}
+
+// WriteByte encodes a single byte to the output writer.
+func (this *Encoder) WriteByte(value byte) (n int, err error) {
+	return this.WriteByte(uint8(value))
+}
+
+// WriteInt8 encodes an 8-bit signed integer to the output writer.
+func (this *Encoder) WriteInt8(value int8) (n int, err error) {
+	return this.WriteUint8(uint8(value))
+}
+
+// WriteUint8 encodes an 8-bit unsigned integer to the output writer.
+func (this *Encoder) WriteUint8(value uint8) (n int, err error) {
+	return this.Write([]byte { byte(value) })
+}
+
+// WriteInt16 encodes an 16-bit signed integer to the output writer.
+func (this *Encoder) WriteInt16(value int16) (n int, err error) {
+	return this.WriteUint16(uint16(value))
+}
+
+// WriteUint16 encodes an 16-bit unsigned integer to the output writer.
+func (this *Encoder) WriteUint16(value uint16) (n int, err error) {
+	return this.Write([]byte {
+		byte(value >> 8),
+		byte(value),
+	})
+}
+
+// WriteInt32 encodes an 32-bit signed integer to the output writer.
+func (this *Encoder) WriteInt32(value int32) (n int, err error) {
+	return this.WriteUint32(uint32(value))
+}
+
+// WriteUint32 encodes an 32-bit unsigned integer to the output writer.
+func (this *Encoder) WriteUint32(value uint32) (n int, err error) {
+	return this.Write([]byte {
+		byte(value >> 24),
+		byte(value >> 16),
+		byte(value >> 8),
+		byte(value),
+	})
+}
+
+// WriteInt64 encodes an 64-bit signed integer to the output writer.
+func (this *Encoder) WriteInt64(value int64) (n int, err error) {
+	return this.WriteUint64(uint64(value))
+}
+
+// WriteUint64 encodes an 64-bit unsigned integer to the output writer.
+func (this *Encoder) WriteUint64(value uint64) (n int, err error) {
+	return this.Write([]byte {
+		byte(value >> 56),
+		byte(value >> 48),
+		byte(value >> 40),
+		byte(value >> 32),
+		byte(value >> 24),
+		byte(value >> 16),
+		byte(value >> 8),
+		byte(value),
+	})
+}
+
+// EncodeGBEU encodes a growing unsigned integer of up to 64 bits to the output
+// writer.
+func (this *Encoder) EncodeGBEU(value uint64) (n int, err error) {
+	// increase if go somehow gets support for over 64 bit integers. we
+	// could also make an expanding int type in goutil to use here, or maybe
+	// there is one in the stdlib. keep this int64 version as well though
+	// because its ergonomic.
+	buffer := [16]byte { }
+	
+	window := (GBEUSize(value) - 1) * 7
+	index := 0
+	for window >= 0 {
+		chunk := uint8(value >> window) & 0x7F
+		if window > 0 {
+			chunk |= 0x80
+		}
+		buffer[index] = chunk
+		
+		index += 1
+		window -= 7
+	}
+	
+	return this.Write(buffer[:])
+}

codec/measure.go

@@ -0,0 +1,11 @@
+package codec
+
+// GBEUSize returns the size (in octets) of a GBEU integer.
+func GBEUSize(value uint64) int {
+	length := 0
+	for {
+		value >>= 7
+		length ++
+		if value == 0 { return length }
+	}
+}

design/pdl.md

@@ -0,0 +1,83 @@
+# PDL Language Definition
+
+PDL allows defining a protocol using HOPP and TAPE.
+
+## Data Types
+
+| Syntax   | TN      | CN | Description
+| -------- | ------- | -: | -----------
+| I5       | SI      |    |   
+| I8       | LI      |  0 | 
+| I16      | LI      |  1 | 
+| I32      | LI      |  3 | 
+| I64      | LI      |  7 | 
+| I128[^2] | LI      | 15 | 
+| I256[^2] | LI      | 31 | 
+| U5       | SI      |    | 
+| U8       | LI      |  0 | 
+| U16      | LI      |  1 | 
+| U32      | LI      |  3 | 
+| U64      | LI      |  7 | 
+| U128[^2] | LI      | 15 | 
+| U256[^2] | LI      | 31 | 
+| F16      | FP      |  1 | 
+| F32      | FP      |  3 | 
+| F64      | FP      |  7 | 
+| F128[^2] | FP      | 15 | 
+| F256[^2] | FP      | 31 | 
+| String   | SBA/LBA |  * | UTF-8 string
+| Buffer   | SBA/LBA |  * | Byte array
+| []<TYPE> | OTA     |  * | Array of any type[^1]
+| Table    | KTV     |  * | 
+
+[^1]: Excluding SI and SBA. I5 and U5 cannot be used in an array, but String and
+Buffer are simply forced to use their "long" variant.
+
+[^2]: Some systems may lack support for this.
+
+## Tokens
+
+| Name     | Syntax                |
+| -------- | --------------------- |
+| Method   | `M[0-9A-Fa-f]{4}`     |
+| Key      | `[0-9A-Fa-f]{4}`      |
+| Ident    | `[A-Za-z][A-Za-z0-9]` |
+| Comma    | `,`                   |
+| LBrace   | `{`                   |
+| RBrace   | `}`                   |
+| LBracket | `[`                   |
+| RBracket | `]`                   |
+
+## Syntax
+
+Types are expressed with an Ident. A table can be used by either writing the
+name of the type (Table), or by defining a schema with curly braces. Arrays must
+be expressed using two matching square brackets before their element type.
+
+A table schema contains comma-separated fields in-between its braces. Each field
+has three parts: the key number (Key), the field name (Ident), and the field
+type. Tables, Arrays, etc. can be nested.
+
+Files directly contain messages and types, which start with a Method token and
+an Ident token respectively. A message consists of the method code (Method), the
+message name (Ident), and the message's root type. This is usually a table, but
+can be anything.
+
+Here is an example of all that:
+
+```
+M0000 Connect {
+	0000 Name String,
+	0001 Password String,
+}
+
+M0001 UserList {
+	0000 Users []User,
+}
+
+User {
+	0000 Name      String,
+	0001 Bio       String,
+	0002 Followers U32,
+}
+```

design/protocol.md

@@ -18,12 +18,10 @@ dependant on which transport is being used.
 A message refers to a block of octets sent within a transaction, paired with an
 unsigned 16-bit method code. The order of messages within a given transaction is
 preserved, but the order of messages accross the entire connection is not
-guaranteed.
-
-The message payload must be 65,535 (unsigned 16-bit integer limit) octets or
-smaller in length. This does not include the method code. Applications are free
-to send whatever data they wish as the payload, but TAPE is recommended for
-encoding it.
+guaranteed. There is no functional limit on the size of a message payload, but
+there may be one depending on which
+[METADAPT sub-protocol](#message-and-transaction-demarcation-protocol-metadapt)
+is in use.
 
 Method codes should be written in upper-case base 16 with the prefix "M" in
 logs, error messages, documentation, etc. For example, the method code 62,206 in
@@ -37,88 +35,78 @@ fucking with you.
 ## Table Pair Encoding (TAPE)
 The Table Pair Encoding (TAPE) scheme is a method for encoding structured data
 within HOPP messages. It defines standard binary encoding methods for common
-data types, as well as a corruption-resistant table structure that maps numeric
-IDs to values. It is designed to allow applications to be presented with data
-they are not equipped to handle while continuing to function normally. This
-enables backwards compatibile application protocol changes.
+data types, as well as aggregate data types such as tables and arrays. It is
+designed to allow applications to be presented with data they are not equipped
+to handle while continuing to function normally. This enables backwards
+compatibile application protocol changes.
 
-### Table Structure
-A table is divided into two sections: the header, and the values. The header
-begins with the number (U16) of pairs in the table, which is then followed by
-that many tag-offset pairs. A tag-offset pair consists of a numerical (U16) tag,
-followed the position (U16) of the value relative to the start of the values
-section. The values section contains the value data for each pair, where the
-start of each value is determined by its offset, and the end is determined by
-the offset of the next value, or the end of the message if there is no value
-after it.
+TAPE expresses types using tags. A tag is 8 bits in size, and is divided into
+two parts: the Type Number (TN), and the Configuration Number (CN). The TN is 3
+bits, and the CN is 5 bits. Both are interpreted as unsigned integers. Both
+sides of the connection must agree on the semantic meaning of the values and
+their arrangement.
 
-Both sections must be in the same order, and because of this, each value offset
-must be greater than or equal to the last. If a message has erratic structure
-(such as unordered or out-of-bounds offsets), implementations may opt to discard
-only the erratic pairs, as well as the pairs directly before those.
+A TAPE structure begins with one root, which consists of a tag followed by a
+payload. This is usually an aggregate data structure such as KTV to allow for
+several different values.
+
+TAPE is based on an encoding method previously developed by silt.
 
 ### Data Value Types
-The table below lists all data value types supported by TAPE.
+The table below lists all data value types supported by TAPE. They are discussed
+in detail in the following sections.
 
-| Name        | Size            | Description                 | Encoding Method
-| ----------- | --------------: | --------------------------- | ---------------
-| I8          |               1 | A signed 8-bit integer      | BETC
-| I16         |               2 | A signed 16-bit integer     | BETC
-| I32         |               4 | A signed 32-bit integer     | BETC
-| I64         |               8 | A signed 64-bit integer     | BETC
-| U8          |               1 | An unsigned 8-bit integer   | BEU
-| U16         |               2 | An unsigned 16-bit integer  | BEU
-| U32         |               4 | An unsigned 32-bit integer  | BEU
-| U64         |               8 | An unsigned 64-bit integer  | BEU
-| Array[^1]   |         SOP[^2] | An array of any above type  | PASTA
-| String      |             N/A | A UTF-8 string              | UTF-8
-| StringArray | n * 2 + SOP[^2] | An array the String type    | VILA
+| TN | Bits | Name | Description
+| -: | ---: | ---- | -----------
+|  0 |  000 | SI   | Small integer
+|  1 |  001 | LI   | Large integer
+|  2 |  010 | FP   | Floating point
+|  3 |  011 | SBA  | Small byte array
+|  4 |  100 | LBA  | Large byte array
+|  5 |  101 | OTA  | One-tag array
+|  6 |  110 | KTV  | Key-tag-value table
+|  7 |  111 | N/A  | Reserved
 
-[^1]: Array types are written as <E>Array, where <E> is the element type. For
-example, an array of I32 would be written as I32Array. StringArray still follows
-this rule, even though it is encoded differently from other arrays. Nesting
-arrays inside of arrays is prohibited. This problem can be avoided in most cases
-by effectively utilizing the table structure, or by improving the design of
-your protocol.
+#### Small Integer (SI)
+SI encodes an integer of up to 5 bits, which are stored in the CN. It has no
+payload. Whether the bits are interpreted as unsigned or as signed two's
+complement is semantic information and must be agreed upon by both sides of the
+connection. Thus, the value may range from 0 to 31 if unsigned, and from -16 to
+17 if signed.
 
-[^2]: SOP (sum of parts) refers to the sum of the size of every item in a data
-structure.
+#### Large Integer (LI)
+LI encodes an integer of up to 256 bits, which are stored in the payload. The CN
+determine the length of the payload in bytes. The integer is big-endian. Whether
+the payload is interpreted as unsigned or as signed two's complement is semantic
+information and must be agreed upon by both sides of the connection. Thus, the
+value may range from 0 to 31 if unsigned, and from -16 to 17 if signed.
 
-### Encoding Methods
-Below are all encoding methods supported by TAPE.
+#### Floating Point (FP)
+FP encodes an IEEE 754 floating point number of up to 256 bits, which are stored
+in the payload. The CN determines the length of the payload in bytes, and it may
+only be one of these values: 16, 32, 64, 128, or 256.
 
-#### BETC
-Big-Endian, Two's Complement signed integer. The size is defined as the least
-amount of whole octets which can fit all bits in the integer, regardless if the
-bits are on or off. Therefore, the size cannot change at runtime.
+#### Small Byte Array (SBA)
+SBA encodes an array of up to 32 bytes, which are stored in the paylod. The
+CN determines the length of the payload in bytes.
 
-#### BEU
-Big-Endian, Unsigned integer. The size is defined as the least amount of whole
-octets which can fit all bits in the integer, regardless if the bits are on or
-off. Therefore, the size cannot change at runtime.
+#### Large Byte Array (LBA)
+LBA encodes an array of up to 2^256 bytes, which are stored in the second part
+of the payload, directly after the length. The length of the data length field
+in bytes is determined by the CN.
 
-#### PASTA
-Packed Single-Type Array. The size is defined as the size of an individual item
-times the number of items. Items are placed one after the other with no gaps
-in-between them, except as required to align the start of each item to the
-nearest whole octet. Items should be of the same type and must be of the same
-size.
+#### One-Tag Array (OTA)
+OTA encodes an array of up to 2^256 items, which are stored in the payload after
+the length field and the item tag, where the length field comes first. Each item
+must be the same length, as they all share the same tag. The length of the data
+length field in bytes is determined by the CN.
 
-#### UTF-8
-UTF-8 string. The size is defined as the least amount of whole octets which can
-fit all bits in the string, regardless if the bits are on or off. The size of
-this type is not fixed and may change at runtime, so this needs to be accounted
-for during use.
-
-#### VILA
-Variable Item Length Array. The size is defined as the least amount of whole
-octets which can fit each item plus one U16 per item. The size of this type is
-not fixed and may change at runtime, so this needs to be accounted for during
-use. The amount of items must be greater than zero. Items are each prefixed by
-their size (in octets) encoded as a U16, and they are placed one after the other
-with no gaps in-between them, except as required to align the start of each item
-to the nearest whole octet. Items should be of the same type but do not need to
-be of the same size.
+#### Key-Tag-Value Table (KTV)
+KTV encodes a table of up to 2^256 key/value pairs, which are stored in the
+payload after the length field. The pairs themselves consist of a 16-bit
+unsigned big-endian key followed by a tag and then the payload. Pair values can
+be of different types and sizes. The order of the pairs is not significant and
+should never be treated as such.
 
 ## Transports
 A transport is a protocol that HOPP connections can run on top of. HOPP
@@ -169,7 +157,6 @@ sun will have expanded to swallow earth by then. Your connection will not last
 that long.
 
 #### Message Chunking
-
 The most significant bit of the payload size field of an MMB is called the Chunk
 Control Bit (CCB). If the CCB of a given MMB is zero, the represented message is
 interpreted as being self-contained and the data is processed immediately. If

dial.go

@@ -1,9 +1,9 @@
 package hopp
 
 import "net"
+import "errors"
 import "context"
 import "crypto/tls"
-import "github.com/quic-go/quic-go"
 
 // Dial opens a connection to a server. The network must be one of "quic",
 // "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, "quic4" and
@@ -19,9 +19,8 @@ type Dialer struct {
 }
 
 // Dial opens a connection to a server. The network must be one of "quic",
-// "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, "quic4" and
-// "quic6" don't do anything as the quic-go package doesn't seem to support this
-// behavior.
+// "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, quic is not
+// supported.
 func (diale Dialer) Dial(ctx context.Context, network, address string) (Conn, error) {
 	switch network {
 	case "quic", "quic4", "quic6": return diale.dialQUIC(ctx, network, address)
@@ -31,12 +30,7 @@ func (diale Dialer) Dial(ctx context.Context, network, address string) (Conn, er
 }
 
 func (diale Dialer) dialQUIC(ctx context.Context, network, address string) (Conn, error) {
-	// sorry i fucking lied to you about the network parameter. for all
-	// quic-go's bullshit bloat, it doesnt even support that. not even when
-	// instantiating a transport. go figure :/
-	conn, err := quic.DialAddr(ctx, address, tlsConfig(diale.TLSConfig), quicConfig())
-	if err != nil { return nil, err }
-	return AdaptB(quicMultiConn { underlying: conn }), nil
+	return nil, errors.New("quic is not yet implemented")
 }
 
 func (diale Dialer) dialUnix(ctx context.Context, network, address string) (Conn, error) {
@@ -60,15 +54,6 @@ func tlsConfig(conf *tls.Config) *tls.Config {
 	return conf
 }
 
-func quicConfig() *quic.Config {
-	return &quic.Config {
-		// TODO: perhaps we might want to put something here
-		// the quic config shouldn't be exported, just set up
-		// automatically. we can't have that strangely built quic-go
-		// package be part of the API, or any third-party packages for
-		// that matter. it must all be abstracted away.
-	}
-}
 
 func quicNetworkToUDPNetwork(network string) (string, error) {
 	switch network {

go.mod

@@ -5,18 +5,4 @@ go 1.23.0
 require (
 	git.tebibyte.media/sashakoshka/go-util v0.9.1
 	github.com/gomarkdown/markdown v0.0.0-20241205020045-f7e15b2f3e62
-	github.com/quic-go/quic-go v0.48.2
-)
-
-require (
-	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
-	github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 // indirect
-	github.com/onsi/ginkgo/v2 v2.9.5 // indirect
-	go.uber.org/mock v0.4.0 // indirect
-	golang.org/x/crypto v0.26.0 // indirect
-	golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 // indirect
-	golang.org/x/mod v0.17.0 // indirect
-	golang.org/x/net v0.28.0 // indirect
-	golang.org/x/sys v0.23.0 // indirect
-	golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d // indirect
 )

go.sum

@@ -1,60 +1,4 @@
 git.tebibyte.media/sashakoshka/go-util v0.9.1 h1:eGAbLwYhOlh4aq/0w+YnJcxT83yPhXtxnYMzz6K7xGo=
 git.tebibyte.media/sashakoshka/go-util v0.9.1/go.mod h1:0Q1t+PePdx6tFYkRuJNcpM1Mru7wE6X+it1kwuOH+6Y=
-github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
-github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
-github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
-github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ=
-github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
-github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
 github.com/gomarkdown/markdown v0.0.0-20241205020045-f7e15b2f3e62 h1:pbAFUZisjG4s6sxvRJvf2N7vhpCvx2Oxb3PmS6pDO1g=
 github.com/gomarkdown/markdown v0.0.0-20241205020045-f7e15b2f3e62/go.mod h1:JDGcbDT52eL4fju3sZ4TeHGsQwhG9nbDV21aMyhwPoA=
-github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
-github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38 h1:yAJXTCF9TqKcTiHJAE8dj7HMvPfh66eeA2JYW7eFpSE=
-github.com/google/pprof v0.0.0-20210407192527-94a9f03dee38/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
-github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
-github.com/onsi/ginkgo/v2 v2.9.5 h1:+6Hr4uxzP4XIUyAkg61dWBw8lb/gc4/X5luuxN/EC+Q=
-github.com/onsi/ginkgo/v2 v2.9.5/go.mod h1:tvAoo1QUJwNEU2ITftXTpR7R1RbCzoZUOs3RonqW57k=
-github.com/onsi/gomega v1.27.6 h1:ENqfyGeS5AX/rlXDd/ETokDz93u0YufY1Pgxuy/PvWE=
-github.com/onsi/gomega v1.27.6/go.mod h1:PIQNjfQwkP3aQAH7lf7j87O/5FiNr+ZR8+ipb+qQlhg=
-github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/quic-go/quic-go v0.48.2 h1:wsKXZPeGWpMpCGSWqOcqpW2wZYic/8T3aqiOID0/KWE=
-github.com/quic-go/quic-go v0.48.2/go.mod h1:yBgs3rWBOADpga7F+jJsb6Ybg1LSYiQvwWlLX+/6HMs=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
-github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
-github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU=
-go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc=
-golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
-golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842 h1:vr/HnozRka3pE4EsMEg1lgkXJkTFJCVUX+S/ZT6wYzM=
-golang.org/x/exp v0.0.0-20240506185415-9bf2ced13842/go.mod h1:XtvwrStGgqGPLc4cjQfWqZHG1YFdYs6swckp8vpsjnc=
-golang.org/x/mod v0.17.0 h1:zY54UmvipHiNd+pm+m0x9KhZ9hl1/7QNMyxXbc6ICqA=
-golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
-golang.org/x/net v0.28.0 h1:a9JDOJc5GMUJ0+UDqmLT86WiEy7iWyIhz8gz8E4e5hE=
-golang.org/x/net v0.28.0/go.mod h1:yqtgsTWOOnlGLG9GFRrK3++bGOUEkNBoHZc8MEDWPNg=
-golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
-golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.23.0 h1:YfKFowiIMvtgl1UERQoTPPToxltDeZfbj4H7dVUCwmM=
-golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
-golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
-golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk=
-golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d h1:vU5i/LfpvrRCpgM/VPfJLg5KjxD3E+hfT1SH+d9zLwg=
-golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
-gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
-gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

listen.go

@@ -1,9 +1,8 @@
 package hopp
 
 import "net"
-import "context"
+import "errors"
 import "crypto/tls"
-import "github.com/quic-go/quic-go"
 
 // Listener is an object which listens for incoming HOPP connections.
 type Listener interface {
@@ -17,7 +16,8 @@ type Listener interface {
 }
 
 // Listen listens for incoming HOPP connections. The network must be one of
-// "quic", "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix".
+// "quic", "quic4", (IPv4-only) "quic6" (IPv6-only), or "unix". For now, quic is
+// not supported.
 func Listen(network, address string) (Listener, error) {
 	switch network {
 	case "quic", "quic4", "quic6": return ListenQUIC(network, address, nil)
@@ -30,19 +30,8 @@ func Listen(network, address string) (Listener, error) {
 // The network must be one of "quic", "quic4", (IPv4-only) or "quic6"
 // (IPv6-only).
 func ListenQUIC(network, address string, tlsConf *tls.Config) (Listener, error) {
-	tlsConf   = tlsConfig(tlsConf)
-	quicConf := quicConfig()
-	udpNetwork, err := quicNetworkToUDPNetwork(network)
-	if err != nil { return nil, err }
-	addr, err := net.ResolveUDPAddr(udpNetwork, address)
-	if err != nil { return nil, err }
-	udpListener, err := net.ListenUDP(udpNetwork, addr)
-	if err != nil { return nil, err }
-	quicListener, err := quic.Listen(udpListener, tlsConf, quicConf)
-	if err != nil { return nil, err }
-	return &listenerQUIC {
-		underlying: quicListener,
-	}, nil
+	// tlsConf   = tlsConfig(tlsConf)
+	return nil, errors.New("quic is not yet implemented")
 }
 
 // ListenUnix listens for incoming HOPP connections using a Unix domain socket
@@ -58,24 +47,6 @@ func ListenUnix(network, address string) (Listener, error) {
 	}, nil
 }
 
-type listenerQUIC struct {
-	underlying *quic.Listener
-}
-
-func (this *listenerQUIC) Accept() (Conn, error) {
-	conn, err := this.underlying.Accept(context.Background())
-	if err != nil { return nil, err }
-	return AdaptB(quicMultiConn { underlying: conn }), nil
-}
-
-func (this *listenerQUIC) Close() error {
-	return this.underlying.Close()
-}
-
-func (this *listenerQUIC) Addr() net.Addr {
-	return this.underlying.Addr()
-}
-
 type listenerUnix struct {
 	underlying *net.UnixListener
 }

quicwrap.go

@@ -1,54 +0,0 @@
-package hopp
-
-import "net"
-import "context"
-import "github.com/quic-go/quic-go"
-
-var _ MultiConn = quicMultiConn { }
-type quicMultiConn struct {
-	underlying quic.Connection
-}
-
-func (conn quicMultiConn) Close() error {
-	return conn.underlying.CloseWithError(0, "good bye")
-}
-
-func (conn quicMultiConn) LocalAddr() net.Addr {
-	return conn.underlying.LocalAddr()
-}
-
-func (conn quicMultiConn) RemoteAddr() net.Addr {
-	return conn.underlying.RemoteAddr()
-}
-
-func (conn quicMultiConn) AcceptStream(ctx context.Context) (Stream, error) {
-	strea, err := conn.underlying.AcceptStream(ctx)
-	if err != nil { return nil, err }
-	return quicStream { underlying: strea }, nil
-}
-
-func (conn quicMultiConn) OpenStream() (Stream, error) {
-	strea, err := conn.underlying.OpenStream()
-	if err != nil { return nil, err }
-	return quicStream { underlying: strea }, nil
-}
-
-type quicStream struct {
-	underlying quic.Stream
-}
-
-func (strea quicStream) Read(buffer []byte) (n int, err error) {
-	return strea.underlying.Read(buffer)
-}
-
-func (strea quicStream) Write(buffer []byte) (n int, err error) {
-	return strea.underlying.Read(buffer)
-}
-
-func (strea quicStream) Close() error {
-	return strea.underlying.Close()
-}
-
-func (strea quicStream) ID() int64 {
-	return int64(strea.underlying.StreamID())
-}

tape/pairs.go

@@ -1,83 +0,0 @@
-package tape
-
-import "iter"
-
-// DecodePairs decodes message tag/value pairs from a byte slice. It returns an
-// iterator over all pairs, where the first value is the tag and the second is
-// the value. If data yielded by the iterator is retained, it must be copied
-// first.
-func DecodePairs(data []byte) (iter.Seq2[uint16, []byte], error) {
-	// determine section bounds
-	if len(data) < 2 { return nil, ErrDataTooLarge }
-	length16, _ := DecodeI16[uint16](data[0:2])
-	data = data[2:]
-	length := int(length16)
-	headerSize := length * 4
-	if len(data) < headerSize { return nil, ErrDataTooLarge }
-	valuesData := data[headerSize:]
-
-	// ensure the value buffer is big enough
-	var valuesSize int
-	for index := range length {
-		offset := index * 4
-		end, _ := DecodeI16[uint16](data[offset + 2:offset + 4])
-		valuesSize = int(end)
-	}
-	if valuesSize > len(valuesData) {
-		return nil, ErrDataTooLarge
-	}
-
-	// return iterator
-	return func(yield func(uint16, []byte) bool) {
-		start := uint16(0)
-		for index := range length {
-			offset := index * 4
-			key , _ := DecodeI16[uint16](data[offset + 0:offset + 2])
-			end,  _ := DecodeI16[uint16](data[offset + 2:offset + 4])
-			// if nextValuesOffset < len(valuesData) {
-				if !yield(key, valuesData[start:end]) {
-					return
-				}
-			// } else {
-				// if !yield(key, nil) {
-					// return
-				// }
-			// }
-			start = end
-		}
-	}, nil
-}
-
-// EncodePairs encodes message tag/value pairs into a byte slice.
-func EncodePairs(pairs map[uint16] []byte) ([]byte, error) {
-	// determine section bounds
-	headerSize := 2 + len(pairs) * 4
-	valuesSize := 0
-	for _, value := range pairs {
-		valuesSize += len(value)
-	}
-
-	// generate data
-	buffer := make([]byte, headerSize + valuesSize)
-	length16, ok := U16CastSafe(len(pairs))
-	if !ok { return nil, ErrDataTooLarge }
-	EncodeI16[uint16](buffer[0:2], length16)
-	index  := 0
-	end    := headerSize
-	for key, value := range pairs {
-		start := end
-		end += len(value)
-		tagOffset := 2 + index * 4
-		end16, ok := U16CastSafe(end - headerSize)
-		if !ok { return nil, ErrDataTooLarge }
-		
-		// write tag and length
-		EncodeI16[uint16](buffer[tagOffset + 0:tagOffset + 2], key)
-		EncodeI16[uint16](buffer[tagOffset + 2:tagOffset + 4], end16)
-
-		// write value
-		copy(buffer[start:end], value)
-		index ++
-	}
-	return buffer, nil
-}

tape/pairs_test.go

@@ -1,62 +0,0 @@
-package tape
-
-import "slices"
-import "testing"
-
-func TestDecodePairs(test *testing.T) {
-	pairs := map[uint16] []byte {
-		3894: []byte("foo"),
-		7:    []byte("br"),
-	}
-	got, err := DecodePairs([]byte {
-		  0,   2,
-		  0,   7,   0,  2,
-		 15,  54,   0,  5,
-		 98, 114,
-		102, 111, 111})
-	if err != nil { test.Fatal(err) }
-	length := 0
-	for key, value := range got {
-		test.Log(key, value)
-		if !slices.Equal(pairs[key], value) { test.Fatal("not equal") }
-		length ++
-	}
-	test.Log("length")
-	if length != len(pairs) { test.Fatal("wrong length") }
-}
-
-func TestEncodePairs(test *testing.T) {
-	pairs := map[uint16] []byte {
-		3894: []byte("foo"),
-		7:    []byte("br"),
-	}
-	got, err := EncodePairs(pairs)
-	if err != nil { test.Fatal(err) }
-	test.Log(got)
-	valid := slices.Equal(got, []byte {
-		  0,   2,
-		 15,  54,   0,  3,
-		  0,   7,   0,  5,
-		102, 111, 111,
-		 98, 114}) ||
-	slices.Equal(got, []byte {
-		  0,   2,
-		  0,   7,   0,  2,
-		 15,  54,   0,  5,
-		 98, 114,
-		102, 111, 111})
-	if !valid { test.Fatal("not equal") }
-}
-
-func FuzzDecodePairs(fuzz *testing.F) {
-	fuzz.Add([]byte {
-		  0,   2,
-		  0,   7,   0,  2,
-		 15,  54,   0,  5,
-		 98, 114,
-		102, 111, 111})
-	fuzz.Fuzz(func(t *testing.T, buffer []byte) {
-		// ensure it does not panic :P
-		DecodePairs(buffer)
-	})
-}

tape/types.go

@@ -1,311 +0,0 @@
-// Package tape implements Table Pair Encoding.
-package tape
-
-import "fmt"
-
-const dataMaxSize = 0xFFFF
-const uint16Max = 0xFFFF
-
-// Error enumerates common errors in this package.
-type Error string; const (
-	ErrWrongBufferLength Error = "wrong buffer length"
-	ErrDataTooLarge      Error = "data too large"
-)
-
-// Error implements the error interface.
-func (err Error) Error() string {
-	return string(err)
-}
-
-// Int8 is any 8-bit integer.
-type Int8  interface { ~uint8  | ~int8 }
-// Int16 is any 16-bit integer.
-type Int16 interface { ~uint16 | ~int16 }
-// Int32 is any 32-bit integer.
-type Int32 interface { ~uint32 | ~int32 }
-// Int64 is any 64-bit integer.
-type Int64 interface { ~uint64 | ~int64 }
-// String is any string.
-type String interface { ~string }
-
-// DecodeI8 decodes an 8 bit integer from the given data.
-func DecodeI8[T Int8](data []byte) (T, error) {
-	if len(data) != 1 { return 0, fmt.Errorf("decoding int8: %w", ErrWrongBufferLength) }
-	return T(data[0]), nil
-}
-
-// EncodeI8 encodes an 8 bit integer into the given buffer.
-func EncodeI8[T Int8](buffer []byte, value T) error {
-	if len(buffer) != 1 { return fmt.Errorf("encoding int8: %w", ErrWrongBufferLength) }
-	buffer[0] = byte(value)
-	return nil
-}
-
-// DecodeI16 decodes a 16 bit integer from the given data.
-func DecodeI16[T Int16](data []byte) (T, error) {
-	if len(data) != 2 { return 0, fmt.Errorf("decoding int16: %w", ErrWrongBufferLength) }
-	return T(data[0]) << 8 | T(data[1]), nil
-}
-
-// EncodeI16 encodes a 16 bit integer into the given buffer.
-func EncodeI16[T Int16](buffer []byte, value T) error {
-	if len(buffer) != 2 { return fmt.Errorf("encoding int16: %w", ErrWrongBufferLength) }
-	buffer[0] = byte(value >> 8)
-	buffer[1] = byte(value)
-	return nil
-}
-
-// DecodeI32 decodes a 32 bit integer from the given data.
-func DecodeI32[T Int32](data []byte) (T, error) {
-	if len(data) != 4 { return 0, fmt.Errorf("decoding int32: %w", ErrWrongBufferLength) }
-	return T(data[0]) << 24 |
-		T(data[1]) << 16 |
-		T(data[2]) <<  8 |
-		T(data[3]), nil
-}
-
-// EncodeI32 encodes a 32 bit integer into the given buffer.
-func EncodeI32[T Int32](buffer []byte, value T) error {
-	if len(buffer) != 4 { return fmt.Errorf("encoding int32: %w", ErrWrongBufferLength) }
-	buffer[0] = byte(value >> 24)
-	buffer[1] = byte(value >> 16)
-	buffer[2] = byte(value >> 8)
-	buffer[3] = byte(value)
-	return nil
-}
-
-// DecodeI64 decodes a 64 bit integer from the given data.
-func DecodeI64[T Int64](data []byte) (T, error) {
-	if len(data) != 8 { return 0, fmt.Errorf("decoding int64: %w", ErrWrongBufferLength) }
-	return T(data[0]) << 56 |
-		T(data[1]) << 48 |
-		T(data[2]) << 40 |
-		T(data[3]) << 32 |
-		T(data[4]) << 24 |
-		T(data[5]) << 16 |
-		T(data[6]) <<  8 |
-		T(data[7]), nil
-}
-
-// EncodeI64 encodes a 64 bit integer into the given buffer.
-func EncodeI64[T Int64](buffer []byte, value T) error {
-	if len(buffer) != 8 { return fmt.Errorf("encoding int64: %w", ErrWrongBufferLength) }
-	buffer[0] = byte(value >> 56)
-	buffer[1] = byte(value >> 48)
-	buffer[2] = byte(value >> 40)
-	buffer[3] = byte(value >> 32)
-	buffer[4] = byte(value >> 24)
-	buffer[5] = byte(value >> 16)
-	buffer[6] = byte(value >> 8)
-	buffer[7] = byte(value)
-	return nil
-}
-
-// DecodeString decodes a string from the given data.
-func DecodeString[T String](data []byte) (T, error) {
-	return T(data), nil
-}
-
-// EncodeString encodes a string into the given buffer.
-func EncodeString[T String](data []byte, value T) error {
-	if len(data) != len(value) { return fmt.Errorf("encoding string: %w", ErrWrongBufferLength) }
-	copy(data, value)
-	return nil
-}
-
-// StringSize returns the size of a string. Returns 0 and an error if the size
-// is too large.
-func StringSize[T String](value T) (int, error) {
-	if len(value) > dataMaxSize { return 0, ErrDataTooLarge }
-	return len(value), nil
-}
-
-// DecodeStringArray decodes a packed string array from the given data.
-func DecodeStringArray[T String](data []byte) ([]T, error) {
-	result := []T { }
-	for len(data) > 0 {
-		if len(data) < 2 { return nil, fmt.Errorf("decoding []string: %w", ErrWrongBufferLength) }
-		itemSize16, _ := DecodeI16[uint16](data[:2])
-		itemSize := int(itemSize16)
-		data = data[2:]
-		if len(data) < itemSize { return nil, fmt.Errorf("decoding []string: %w", ErrWrongBufferLength) }
-		result = append(result, T(data[:itemSize]))
-		data = data[itemSize:]
-	}
-	return result, nil
-}
-
-// EncodeStringArray encodes a packed string array into the given buffer.
-func EncodeStringArray[T String](buffer []byte, value []T) error {
-	for _, item := range value {
-		length, err := StringSize(item)
-		if err != nil { return err }
-		if len(buffer) < 2 + length { return fmt.Errorf("encoding []string: %w", ErrWrongBufferLength) }
-		EncodeI16(buffer[:2], uint16(length))
-		buffer = buffer[2:]
-		copy(buffer, item)
-		buffer = buffer[length:]
-	}
-	if len(buffer) > 0 { return fmt.Errorf("encoding []string: %w", ErrWrongBufferLength) }
-	return nil
-}
-
-// StringArraySize returns the size of a packed string array. Returns 0 and an
-// error if the size is too large.
-func StringArraySize[T String](value []T) (int, error) {
-	total := 0
-	for _, item := range value {
-		total += 2 + len(item)
-	}
-	if total > dataMaxSize { return 0, ErrDataTooLarge }
-	return total, nil
-}
-
-// DecodeI8Array decodes a packed array of 8 bit integers from the given data.
-func DecodeI8Array[T Int8](data []byte) ([]T, error) {
-	result := make([]T, len(data))
-	for index, item := range data {
-		result[index] = T(item)
-	}
-	return result, nil
-}
-
-// EncodeI8Array encodes a packed array of 8 bit integers into the given buffer.
-func EncodeI8Array[T Int8](buffer []byte, value []T) error {
-	if len(buffer) != len(value) { return fmt.Errorf("encoding []int8: %w", ErrWrongBufferLength) }
-	for index, item := range value {
-		buffer[index] = byte(item)
-	}
-	return nil
-}
-
-// I8ArraySize returns the size of a packed 8 bit integer array. Returns 0 and
-// an error if the size is too large.
-func I8ArraySize[T Int8](value []T) (int, error) {
-	total := len(value)
-	if total > dataMaxSize { return 0, ErrDataTooLarge }
-	return total, nil
-}
-
-// DecodeI16Array decodes a packed array of 16 bit integers from the given data.
-func DecodeI16Array[T Int16](data []byte) ([]T, error) {
-	if len(data) % 2 != 0 { return nil, fmt.Errorf("decoding []int16: %w", ErrWrongBufferLength) }
-	length := len(data) / 2
-	result := make([]T, length)
-	for index := range length {
-		offset := index * 2
-		result[index] = T(data[offset]) << 8 | T(data[offset + 1])
-	}
-	return result, nil
-}
-
-// EncodeI16Array encodes a packed array of 16 bit integers into the given buffer.
-func EncodeI16Array[T Int16](buffer []byte, value []T) error {
-	if len(buffer) != len(value) * 2 { return fmt.Errorf("encoding []int16: %w", ErrWrongBufferLength) }
-	for _, item := range value {
-		buffer[0] = byte(item >> 8)
-		buffer[1] = byte(item)
-		buffer = buffer[2:]
-	}
-	return nil
-}
-
-// I16ArraySize returns the size of a packed 16 bit integer array. Returns 0 and
-// an error if the size is too large.
-func I16ArraySize[T Int16](value []T) (int, error) {
-	total := len(value) * 2
-	if total > dataMaxSize { return 0, ErrDataTooLarge }
-	return total, nil
-}
-
-// DecodeI32Array decodes a packed array of 32 bit integers from the given data.
-func DecodeI32Array[T Int32](data []byte) ([]T, error) {
-	if len(data) % 4 != 0 { return nil, fmt.Errorf("decoding []int32: %w", ErrWrongBufferLength) }
-	length := len(data) / 4
-	result := make([]T, length)
-	for index := range length {
-		offset := index * 4
-		result[index] =
-			T(data[offset + 0]) << 24 |
-			T(data[offset + 1]) << 16 |
-			T(data[offset + 2]) <<  8 |
-			T(data[offset + 3])
-	}
-	return result, nil
-}
-
-// EncodeI32Array encodes a packed array of 32 bit integers into the given buffer.
-func EncodeI32Array[T Int32](buffer []byte, value []T) error {
-	if len(buffer) != len(value) * 4 { return fmt.Errorf("encoding []int32: %w", ErrWrongBufferLength) }
-	for _, item := range value {
-		buffer[0] = byte(item >> 24)
-		buffer[1] = byte(item >> 16)
-		buffer[2] = byte(item >> 8)
-		buffer[3] = byte(item)
-		buffer = buffer[4:]
-	}
-	return nil
-}
-
-// I32ArraySize returns the size of a packed 32 bit integer array. Returns 0 and
-// an error if the size is too large.
-func I32ArraySize[T Int32](value []T) (int, error) {
-	total := len(value) * 4
-	if total > dataMaxSize { return 0, ErrDataTooLarge }
-	return total, nil
-}
-
-// DecodeI64Array decodes a packed array of 32 bit integers from the given data.
-func DecodeI64Array[T Int64](data []byte) ([]T, error) {
-	if len(data) % 8 != 0 { return nil, fmt.Errorf("decoding []int64: %w", ErrWrongBufferLength) }
-	length := len(data) / 8
-	result := make([]T, length)
-	for index := range length {
-		offset := index * 8
-		result[index] =
-			T(data[offset + 0]) << 56 |
-			T(data[offset + 1]) << 48 |
-			T(data[offset + 2]) << 40 |
-			T(data[offset + 3]) << 32 |
-			T(data[offset + 4]) << 24 |
-			T(data[offset + 5]) << 16 |
-			T(data[offset + 6]) <<  8 |
-			T(data[offset + 7])
-	}
-	return result, nil
-}
-
-// EncodeI64Array encodes a packed array of 64 bit integers into the given buffer.
-func EncodeI64Array[T Int64](buffer []byte, value []T) error {
-	if len(buffer) != len(value) * 8 { return fmt.Errorf("encoding []int64: %w", ErrWrongBufferLength) }
-	for _, item := range value {
-		buffer[0] = byte(item >> 56)
-		buffer[1] = byte(item >> 48)
-		buffer[2] = byte(item >> 40)
-		buffer[3] = byte(item >> 32)
-		buffer[4] = byte(item >> 24)
-		buffer[5] = byte(item >> 16)
-		buffer[6] = byte(item >> 8)
-		buffer[7] = byte(item)
-		buffer = buffer[8:]
-	}
-	return nil
-}
-
-// I64ArraySize returns the size of a packed 64 bit integer array. Returns 0 and
-// an error if the size is too large.
-func I64ArraySize[T Int64](value []T) (int, error) {
-	total := len(value) * 8
-	if total > dataMaxSize { return 0, ErrDataTooLarge }
-	return total, nil
-}
-
-// U16CastSafe safely casts an integer to a uint16. If an overflow or underflow
-// occurs, it will return (0, false).
-func U16CastSafe(n int) (uint16, bool) {
-	if n < uint16Max && n >= 0 {
-		return uint16(n), true
-	} else {
-		return 0, false
-	}
-}

tape/types_test.go

@@ -1,292 +0,0 @@
-package tape
-
-import "slices"
-import "errors"
-import "testing"
-import "math/rand"
-
-const largeNumberNTestRounds = 2048
-const randStringBytes        = "-abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-
-func TestI8(test *testing.T) {
-	var buffer [16]byte
-	err := EncodeI8[uint8](buffer[:], 5)
-	if err.Error() != "encoding int8: wrong buffer length" { test.Fatal(err) }
-	err = EncodeI8[uint8](buffer[:0], 5)
-	if err.Error() != "encoding int8: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI8[uint8](buffer[:])
-	if err.Error() != "decoding int8: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI8[uint8](buffer[:0])
-	if err.Error() != "decoding int8: wrong buffer length" { test.Fatal(err) }
-	
-	for number := range uint8(255) {
-		err := EncodeI8[uint8](buffer[:1], number)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI8[uint8](buffer[:1])
-		if err != nil { test.Fatal(err) }
-		if decoded != number {
-			test.Fatalf("%d != %d", decoded, number)
-		}
-	}
-}
-
-func TestI16(test *testing.T) {
-	var buffer [16]byte
-	err := EncodeI16[uint16](buffer[:], 5)
-	if err.Error() != "encoding int16: wrong buffer length" { test.Fatal(err) }
-	err = EncodeI16[uint16](buffer[:0], 5)
-	if err.Error() != "encoding int16: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI16[uint16](buffer[:])
-	if err.Error() != "decoding int16: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI16[uint16](buffer[:0])
-	if err.Error() != "decoding int16: wrong buffer length" { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		number := uint16(rand.Int())
-		err := EncodeI16[uint16](buffer[:2], number)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI16[uint16](buffer[:2])
-		if err != nil { test.Fatal(err) }
-		if decoded != number {
-			test.Fatalf("%d != %d", decoded, number)
-		}
-	}
-}
-
-func TestI32(test *testing.T) {
-	var buffer [16]byte
-	err := EncodeI32[uint32](buffer[:], 5)
-	if err.Error() != "encoding int32: wrong buffer length" { test.Fatal(err) }
-	err = EncodeI32[uint32](buffer[:0], 5)
-	if err.Error() != "encoding int32: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI32[uint32](buffer[:])
-	if err.Error() != "decoding int32: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI32[uint32](buffer[:0])
-	if err.Error() != "decoding int32: wrong buffer length" { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		number := uint32(rand.Int())
-		err := EncodeI32[uint32](buffer[:4], number)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI32[uint32](buffer[:4])
-		if err != nil { test.Fatal(err) }
-		if decoded != number {
-			test.Fatalf("%d != %d", decoded, number)
-		}
-	}
-}
-
-func TestI64(test *testing.T) {
-	var buffer [16]byte
-	err := EncodeI64[uint64](buffer[:], 5)
-	if err.Error() != "encoding int64: wrong buffer length" { test.Fatal(err) }
-	err = EncodeI64[uint64](buffer[:0], 5)
-	if err.Error() != "encoding int64: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI64[uint64](buffer[:])
-	if err.Error() != "decoding int64: wrong buffer length" { test.Fatal(err) }
-	_, err = DecodeI64[uint64](buffer[:0])
-	if err.Error() != "decoding int64: wrong buffer length" { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		number := uint64(rand.Int())
-		err := EncodeI64[uint64](buffer[:8], number)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI64[uint64](buffer[:8])
-		if err != nil { test.Fatal(err) }
-		if decoded != number {
-			test.Fatalf("%d != %d", decoded, number)
-		}
-	}
-}
-
-func TestString(test *testing.T) {
-	var buffer [16]byte
-	err := EncodeString[string](buffer[:], "hello")
-	if !errIs(err, ErrWrongBufferLength, "encoding string: wrong buffer length") { test.Fatal(err) }
-	err = EncodeString[string](buffer[:0], "hello")
-	if !errIs(err, ErrWrongBufferLength, "encoding string: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeString[string](buffer[:])
-	if err != nil { test.Fatal(err) }
-	_, err = DecodeString[string](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		length := rand.Intn(16)
-		str := randString(length)
-		err := EncodeString[string](buffer[:length], str)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeString[string](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if decoded != str {
-			test.Fatalf("%s != %s", decoded, str)
-		}
-	}
-}
-
-func TestI8Array(test *testing.T) {
-	var buffer [64]byte
-	err := EncodeI8Array[uint8](buffer[:], []uint8 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int8: wrong buffer length") { test.Fatal(err) }
-	err = EncodeI8Array[uint8](buffer[:0], []uint8 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int8: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeI8Array[uint8](buffer[:])
-	if err != nil { test.Fatal(err) }
-	_, err = DecodeI8Array[uint8](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		array := randInts[uint8](rand.Intn(16))
-		length, _ := I8ArraySize(array)
-		if length != len(array) { test.Fatalf("%d != %d", length, len(array)) }
-		err := EncodeI8Array[uint8](buffer[:length], array)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI8Array[uint8](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if !slices.Equal(decoded, array) {
-			test.Fatalf("%v != %v", decoded, array)
-		}
-	}
-}
-
-func TestI16Array(test *testing.T) {
-	var buffer [128]byte
-	err := EncodeI16Array[uint16](buffer[:], []uint16 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int16: wrong buffer length") { test.Fatal(err) }
-	err = EncodeI16Array[uint16](buffer[:0], []uint16 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int16: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeI16Array[uint16](buffer[:])
-	if err != nil { test.Fatal(err) }
-	_, err = DecodeI16Array[uint16](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		array := randInts[uint16](rand.Intn(16))
-		length, _ := I16ArraySize(array)
-		if length != 2 * len(array) { test.Fatalf("%d != %d", length, 2 * len(array)) }
-		err := EncodeI16Array[uint16](buffer[:length], array)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI16Array[uint16](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if !slices.Equal(decoded, array) {
-			test.Fatalf("%v != %v", decoded, array)
-		}
-	}
-}
-
-func TestI32Array(test *testing.T) {
-	var buffer [256]byte
-	err := EncodeI32Array[uint32](buffer[:], []uint32 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int32: wrong buffer length") { test.Fatal(err) }
-	err = EncodeI32Array[uint32](buffer[:0], []uint32 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int32: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeI32Array[uint32](buffer[:])
-	if err != nil { test.Fatal(err) }
-	_, err = DecodeI32Array[uint32](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		array := randInts[uint32](rand.Intn(16))
-		length, _ := I32ArraySize(array)
-		if length != 4 * len(array) { test.Fatalf("%d != %d", length, 4 * len(array)) }
-		err := EncodeI32Array[uint32](buffer[:length], array)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI32Array[uint32](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if !slices.Equal(decoded, array) {
-			test.Fatalf("%v != %v", decoded, array)
-		}
-	}
-}
-
-func TestI64Array(test *testing.T) {
-	var buffer [512]byte
-	err := EncodeI64Array[uint64](buffer[:], []uint64 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int64: wrong buffer length") { test.Fatal(err) }
-	err = EncodeI64Array[uint64](buffer[:0], []uint64 { 0, 4, 50, 19 })
-	if !errIs(err, ErrWrongBufferLength, "encoding []int64: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeI64Array[uint64](buffer[:])
-	if err != nil { test.Fatal(err) }
-	_, err = DecodeI64Array[uint64](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		array := randInts[uint64](rand.Intn(16))
-		length, _ := I64ArraySize(array)
-		if length != 8 * len(array) { test.Fatalf("%d != %d", length, 8 * len(array)) }
-		err := EncodeI64Array[uint64](buffer[:length], array)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeI64Array[uint64](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if !slices.Equal(decoded, array) {
-			test.Fatalf("%v != %v", decoded, array)
-		}
-	}
-}
-
-func TestStringArray(test *testing.T) {
-	var buffer [8192]byte
-	err := EncodeStringArray[string](buffer[:], []string { "0", "4", "50", "19" })
-	if !errIs(err, ErrWrongBufferLength, "encoding []string: wrong buffer length") { test.Fatal(err) }
-	err = EncodeStringArray[string](buffer[:0], []string { "0", "4", "50", "19" })
-	if !errIs(err, ErrWrongBufferLength, "encoding []string: wrong buffer length") { test.Fatal(err) }
-	_, err = DecodeStringArray[string](buffer[:0])
-	if err != nil { test.Fatal(err) }
-	
-	for _ = range largeNumberNTestRounds {
-		array := randStrings[string](rand.Intn(16), 16)
-		length, _ := StringArraySize(array)
-		// TODO test length
-		err := EncodeStringArray[string](buffer[:length], array)
-		if err != nil { test.Fatal(err) }
-		decoded, err := DecodeStringArray[string](buffer[:length])
-		if err != nil { test.Fatal(err) }
-		if !slices.Equal(decoded, array) {
-			test.Fatalf("%v != %v", decoded, array)
-		}
-	}
-}
-
-func TestU16CastSafe(test *testing.T) {
-	number, ok := U16CastSafe(90_000)
-	if ok { test.Fatalf("false positive: %v, %v", number, ok) }
-	number, ok = U16CastSafe(-478)
-	if ok { test.Fatalf("false positive: %v, %v", number, ok) }
-	number, ok = U16CastSafe(3870)
-	if !ok { test.Fatalf("false negative: %v, %v", number, ok) }
-	if got, correct := number, uint16(3870); got != correct {
-		test.Fatalf("not equal: %v %v", got, correct)
-	}
-	number, ok = U16CastSafe(0)
-	if !ok { test.Fatalf("false negative: %v, %v", number, ok) }
-	if got, correct := number, uint16(0); got != correct {
-		test.Fatalf("not equal: %v %v", got, correct)
-	}
-}
-
-func randString(length int) string {
-	buffer := make([]byte, length)
-	for index := range buffer {
-		buffer[index] = randStringBytes[rand.Intn(len(randStringBytes))]
-	}
-	return string(buffer)
-}
-
-func randInts[T interface { ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 }] (length int) []T {
-	buffer := make([]T, length)
-	for index := range buffer {
-		buffer[index] = T(rand.Int())
-	}
-	return buffer
-}
-
-func randStrings[T interface { ~string }] (length, maxItemLength int) []T {
-	buffer := make([]T, length)
-	for index := range buffer {
-		buffer[index] = T(randString(rand.Intn(maxItemLength)))
-	}
-	return buffer
-}
-
-func errIs(err error, wraps error, description string) bool {
-	return err != nil && (wraps == nil || errors.Is(err, wraps)) && err.Error() == description
-}