numeric

package

v0.1.0 Latest Latest Go to latest Published: Mar 7, 2023 License: MIT Imports: 4 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/roblovelock/gobble

Links

Open Source Insights

Documentation ¶

Overview ¶

Package numeric provides parsers for recognizing numeric bytes

Index ¶

func Int16BE() parser.Parser[parser.Reader, int16]
func Int16LE() parser.Parser[parser.Reader, int16]
func Int32BE() parser.Parser[parser.Reader, int32]
func Int32LE() parser.Parser[parser.Reader, int32]
func Int64BE() parser.Parser[parser.Reader, int64]
func Int64LE() parser.Parser[parser.Reader, int64]
func Int8() parser.Parser[parser.Reader, int8]
func UInt16BE() parser.Parser[parser.Reader, uint16]
func UInt16LE() parser.Parser[parser.Reader, uint16]
func UInt32BE() parser.Parser[parser.Reader, uint32]
func UInt32LE() parser.Parser[parser.Reader, uint32]
func UInt64BE() parser.Parser[parser.Reader, uint64]
func UInt64LE() parser.Parser[parser.Reader, uint64]
func UInt8() parser.Parser[parser.Reader, uint8]

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

func Int16BE ¶

func Int16BE() parser.Parser[parser.Reader, int16]

Int16BE returns a big endian 2 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int16BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x01, 3})
	numericParser := numeric.Int16BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int16LE ¶

func Int16LE() parser.Parser[parser.Reader, int16]

Int16LE returns a little endian 2 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int16LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 3})
	numericParser := numeric.Int16LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int32BE ¶

func Int32BE() parser.Parser[parser.Reader, int32]

Int32BE returns a big endian 4 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int32BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x00, 0x00, 0x01, 3})
	numericParser := numeric.Int32BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int32LE ¶

func Int32LE() parser.Parser[parser.Reader, int32]

Int32LE returns a little endian 4 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int32LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 0x00, 0x00, 3})
	numericParser := numeric.Int32LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int64BE ¶

func Int64BE() parser.Parser[parser.Reader, int64]

Int64BE returns a big endian 8 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int64BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 3})
	numericParser := numeric.Int64BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int64LE ¶

func Int64LE() parser.Parser[parser.Reader, int64]

Int64LE returns a little endian 8 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int64LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3})
	numericParser := numeric.Int64LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func Int8 ¶

func Int8() parser.Parser[parser.Reader, int8]

Int8 returns a 1 byte signed integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.Int8()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{1, 2, 3})
	numericParser := numeric.Int8()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [2 3]

func UInt16BE ¶

func UInt16BE() parser.Parser[parser.Reader, uint16]

UInt16BE returns a big endian 2 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt16BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x01, 3})
	numericParser := numeric.UInt16BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt16LE ¶

func UInt16LE() parser.Parser[parser.Reader, uint16]

UInt16LE returns a little endian 2 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt16LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 3})
	numericParser := numeric.UInt16LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt32BE ¶

func UInt32BE() parser.Parser[parser.Reader, uint32]

UInt32BE returns a big endian 4 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt32BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x00, 0x00, 0x01, 3})
	numericParser := numeric.UInt32BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt32LE ¶

func UInt32LE() parser.Parser[parser.Reader, uint32]

UInt32LE returns a little endian 4 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt32LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 0x00, 0x00, 3})
	numericParser := numeric.UInt32LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt64BE ¶

func UInt64BE() parser.Parser[parser.Reader, uint64]

UInt64BE returns a big endian 8 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt64BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 3})
	numericParser := numeric.UInt64BE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt64LE ¶

func UInt64LE() parser.Parser[parser.Reader, uint64]

UInt64LE returns a little endian 8 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt64LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 3})
	numericParser := numeric.UInt64LE()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [3]

func UInt8 ¶

func UInt8() parser.Parser[parser.Reader, uint8]

UInt8 returns a 1 byte unsigned integer. io.EOF is returned if the input contains too few bytes

Example (EndOfFile) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{})
	numericParser := numeric.UInt8()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: '%v', Remainder: %v", match, err, remainder)

}

Output:

Match: 0, Error: 'EOF', Remainder: []

Example (Match) ¶

package main

import (
	"bytes"
	"fmt"
	"github.com/roblovelock/gobble/pkg/parser/numeric"
	"io"
)

func main() {
	input := bytes.NewReader([]byte{1, 2, 3})
	numericParser := numeric.UInt8()

	match, err := numericParser(input)
	remainder, _ := io.ReadAll(input)
	fmt.Printf("Match: %d, Error: %v, Remainder: %v", match, err, remainder)

}

Output:

Match: 1, Error: <nil>, Remainder: [2 3]

Types ¶

This section is empty.

Source Files ¶

View all Source files

numeric.go

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func Int16BE ¶

func Int16LE ¶

func Int32BE ¶

func Int32LE ¶

func Int64BE ¶

func Int64LE ¶

func Int8 ¶

func UInt16BE ¶

func UInt16LE ¶

func UInt32BE ¶

func UInt32LE ¶

func UInt64BE ¶

func UInt64LE ¶

func UInt8 ¶

Types ¶

Source Files ¶