byteslice

README

= byteslice

image:https://travis-ci.org/rlespinasse/byteslice.svg?branch=master["Build Status", link="https://travis-ci.org/rlespinasse/byteslice"]
image:https://coveralls.io/repos/github/rlespinasse/byteslice/badge.svg?branch=master["Coverage Status", link="https://coveralls.io/github/rlespinasse/byteslice?branch=master"]

== How to

=== test it with coverage

[source,shell]
-----
$ go test -coverprofile=/tmp/byteslice-cover .
ok  	github.com/rlespinasse/byteslice	0.007s	coverage: 100.0% of statements
-----

=== launch the benchmark

[source,shell]
-----
$ go test -bench=. .
goos: ...
goarch: ...
pkg: github.com/rlespinasse/byteslice
BenchmarkRBitState/get_low_bit_of_high_nibble-8         	2000000000	         1.99 ns/op
BenchmarkRBitState/get_low_bit-8                        	2000000000	         1.96 ns/op
...
PASS
ok  	github.com/rlespinasse/byteslice	158.442s
-----

== Documentation Site

See https://godoc.org/github.com/rlespinasse/byteslice

Documentation

Overview

Package byteslice provides functions to manipulate byte slices with endianness support (little, and big endian order)

Index

• func Flip(data []byte) []byte
• func LPad(data []byte, length int, filler byte) []byte
• func LSet(data, setData []byte) []byte
• func LShift(data []byte, shift uint64) []byte
• func LSubset(data []byte, leastSignificantBit, mostSignificantBit uint64) []byte
• func LToggle(data, toggleData []byte) []byte
• func LUnset(data, unsetData []byte) []byte
• func RBit(data byte, bit uint8) byte
• func RBitsSubset(data byte, leastSignificantBit, mostSignificantBit uint8) byte
• func RPad(data []byte, length int, filler byte) []byte
• func RSet(data, setData []byte) []byte
• func RShift(data []byte, shift uint64) []byte
• func RSubset(data []byte, leastSignificantBit, mostSignificantBit uint64) []byte
• func RToggle(data, toggleData []byte) []byte
• func RUnset(data, unsetData []byte) []byte
• func Reverse(data []byte) []byte
• func Set(data, setData []byte) ([]byte, error)
• func Toggle(data, toggleData []byte) ([]byte, error)
• func Unset(data, unsetData []byte) ([]byte, error)

Examples

• LPad
• LSet
• LToggle
• RBit
• RBitsSubset
• RSet
• Reverse
• Toggle
• Toggle (Simple)

Functions

func Flip

func Flip(data []byte) []byte

Flip apply NOT operation to a byte slice to flip it.

func LPad

func LPad(data []byte, length int, filler byte) []byte

LPad pads the left-side of a byte slice with a filler byte.

Example

data := []byte{0x55, 0xDA, 0xBA}

fmt.Printf("%x\n", LPad(data, 5, 0x22))

Output:

222255daba

func LSet

func LSet(data, setData []byte) []byte

LSet apply OR operation on a byte slice with an "set" byte slice using big endian order.

Example

data := []byte{0xAA, 0xCA, 0x55}
setData := []byte{0x10, 0x12}

fmt.Printf("%x\n", LSet(data, setData))

Output:

bada55

func LShift

func LShift(data []byte, shift uint64) []byte

LShift apply left shift operation to an byte slice.

func LSubset

func LSubset(data []byte, leastSignificantBit, mostSignificantBit uint64) []byte

LSubset get the byte slice of a subset of the big endian ordered data byte defined by the least significant bit and the most significant bit.

func LToggle

func LToggle(data, toggleData []byte) []byte

LToggle apply XOR operation on a byte slice with an "toggle" byte slice using big endian order.

Example

data := []byte{0xAB, 0xCB, 0x44}
setData := []byte{0x11, 0x11, 0x11}

fmt.Printf("%x\n", LToggle(data, setData))

Output:

bada55

func LUnset

func LUnset(data, unsetData []byte) []byte

LUnset apply AND operation on a byte slice with an "unset" byte slice using big endian order.

func RBit

func RBit(data byte, bit uint8) byte

RBit get a specific bit of the little endian ordered data byte.

Example

fmt.Printf("%x\n", RBit(0x55, 6))

Output:

40

func RBitsSubset

func RBitsSubset(data byte, leastSignificantBit, mostSignificantBit uint8) byte

RBitsSubset get the byte value of a subset of the little endian ordered data byte defined by the least significant bit and the most significant bit.

Example

fmt.Printf("%x\n", RBitsSubset(0x55, 2, 6))

Output:

15

func RPad

func RPad(data []byte, length int, filler byte) []byte

RPad pads the right-side of a byte slice with a filler byte.

func RSet

func RSet(data, setData []byte) []byte

RSet apply OR operation on a byte slice with an "set" byte slice using little endian order.

Example

data := []byte{0xBA, 0xCA, 0x44}
setData := []byte{0x12, 0x11}

fmt.Printf("%x\n", RSet(data, setData))

Output:

bada55

func RShift

func RShift(data []byte, shift uint64) []byte

RShift apply right shift operation to an byte slice.

func RSubset

func RSubset(data []byte, leastSignificantBit, mostSignificantBit uint64) []byte

RSubset get the byte slice of a subset of the little endian ordered data byte defined by the least significant bit and the most significant bit.

func RToggle

func RToggle(data, toggleData []byte) []byte

RToggle apply XOR operation on a byte slice with an "toggle" byte slice using little endian order.

func RUnset

func RUnset(data, unsetData []byte) []byte

RUnset apply AND operation on a byte slice with an "unset" byte slice using little endian order.

func Reverse

func Reverse(data []byte) []byte

Reverse change the order of the byte slice.

Example

data := []byte{0x55, 0xDA, 0xBA}

fmt.Printf("%x\n", Reverse(data))

Output:

bada55

func Set

func Set(data, setData []byte) ([]byte, error)

Set apply OR operation on a byte slice with an "set" byte slice (must have the same size).

func Toggle

func Toggle(data, toggleData []byte) ([]byte, error)

Toggle apply XOR operation on a byte slice with an "toggle" byte slice (must have the same size).

Example

data := []byte{0xbb, 0xdb, 0x54}
toggle := []byte{0x01, 0x01, 0x01}

output, _ := Toggle(data, toggle)
fmt.Printf("%x\n", output)

Output:

bada55

Example (Simple)

data := []byte{0x00, 0x01, 0x00}
toggle := []byte{0x01, 0x00, 0x01}

output, _ := Toggle(data, toggle)
fmt.Printf("%x\n", output)

Output:

010101

func Unset

func Unset(data, unsetData []byte) ([]byte, error)

Unset apply AND operation on a byte slice with an "unset" byte slice (must have the same size).